Handle inner classes

Author: ghickman

justfile

@@ -36,5 +36,5 @@ test *args="":
     -uv run -m coverage report
     uv run -m coverage html
 
-e2e:
-    classify tests.dummy_class.DummyClass --django-settings classify.contrib.django.settings --console-theme dracula
+e2e *args="--console-theme dracula":
+    classify tests.dummy_class.DummyClass --django-settings classify.contrib.django.settings {{ args }}

src/classify/library.py

@@ -38,6 +38,7 @@ class Class:
     ancestors: list[str]
     parents: list[str]
     attributes: dict[str, list[Attribute]]
+    classes: list["Class"]
     methods: dict[str, list["Method"]]
     properties: list = Factory(list)
 
@@ -101,7 +102,7 @@ def build_methods(members: list[Member]) -> Generator[Method, None, None]:
         yield Method(
             name=member.name,
             docstring=pydoc.getdoc(member.obj),
-            defining_class=member.cls,
+            defining_class=member.cls.__name__,
             arguments=arguments,
             code="".join(lines),
             lines=Line(start=start_line, total=len(lines)),
@@ -117,16 +118,25 @@ def classify[C](obj: type[C]) -> Class:
     # build up dicts of attrs&methods, by name, because they can be defined on
     # more than one class in the MRO
     attributes = collections.defaultdict(list)
+    classes = []
     methods = collections.defaultdict(list)
 
     for cls in mro:
         members = list(get_members(cls))
 
         ## ATTRIBUTES
-        class_attrs = [m for m in members if m.kind == "data"]
+        class_attrs = [
+            m for m in members if m.kind == "data" and not inspect.isclass(m.obj)
+        ]
         for attribute in build_attributes(class_attrs):
             attributes[attribute.name].append(attribute)
 
+        ## CLASSES
+        inner_classes = [
+            m for m in members if m.kind == "data" and inspect.isclass(m.obj)
+        ]
+        classes.extend(classify(c.obj) for c in inner_classes)
+
         ## METHODS
         instance_methods = [
             m for m in members if m.kind in ["method", "class method", "static method"]
@@ -137,9 +147,10 @@ def classify[C](obj: type[C]) -> Class:
     return Class(
         name=obj.__name__,
         docstring=pydoc.getdoc(obj),
-        ancestors=[k.__name__ for k in mro],
-        parents=inspect.getclasstree([obj])[-1][0][1],
+        ancestors=[k.__name__ for k in mro[:-1]],
+        parents=get_parents(obj),
         attributes=dict(sorted(attributes.items())),
+        classes=sorted(classes),
         methods=dict(sorted(methods.items())),
     )
 
@@ -171,6 +182,16 @@ def get_members(obj) -> list[Member]:
     ]
 
 
+def get_parents[C](obj: type[C]) -> list[str]:
+    tree = inspect.getclasstree([obj])
+
+    # getclasstree returns a list of tuples, containing a class, and tuple with
+    # that classes parents.  We just want the parents for the given obj.
+    raw_parents = tree[-1][0][1]
+
+    return [c for c in raw_parents if c is not builtins.object]
+
+
 def resolve(thing: str) -> type[C]:
     """Find the given thing and ensure it's a class"""
     sys.path.insert(0, "")

src/classify/renderers/string.py

@@ -1,23 +1,36 @@
-from ..library import Class
+from ..library import Class, Method
 
 
-indent = " " * 4
+# define this here so we know what "1" indent is and can remove it for inner
+# class declarations
+DEFAULT_INDENT_WIDTH = 4
 
 
-def attributes(attributes):
+def attributes(attributes, indent) -> str:
     attrs = []
     for name, definitions in attributes.items():
         value = definitions[-1].value
         attrs.append(f"{indent}{name} = {value}\n")
     return "".join(attrs)
 
 
-def declaration(name, parents):
-    parents = ", ".join([p.__name__ for p in parents])
-    return f"class {name}({parents}):"
+def classes(classes, indent) -> str:
+    content = [to_string(c, indent=indent + indent) for c in classes]
+    return "".join(content)
 
 
-def docstring(docstring):
+def declaration(name, parents, indent) -> str:
+    indent = indent[:-DEFAULT_INDENT_WIDTH]
+    content = f"{indent}class {name}"
+
+    if parents:
+        parents = ", ".join([p.__name__ for p in parents])
+        content = f"{content}({parents})"
+
+    return f"{content}:"
+
+
+def docstring(docstring, indent) -> str:
     if not docstring:
         return ""
 
@@ -27,23 +40,31 @@ def docstring(docstring):
     return f"{quotes}{block}{quotes}"
 
 
-def methods(methods):
+def methods(methods: dict[str, list[Method]], indent) -> str:
     content = ""
     for definitions in methods.values():
-        for d in definitions:
-            lines = d.code.split("\n")[:-1]
+        for i, method in enumerate(definitions):
+            if len(definitions) > 1 and i == 0:
+                content += f"{indent}# Defined on: {method.defining_class}\n"
+            lines = method.code.split("\n")[:-1]
             for line in lines:
+                # TODO: dedent code at source so defined indent isn't tied to
+                # presentation indent
                 content += f"{indent}{line[4:]}\n"
             content += "\n"
-    return content
+
+    # add strip to remove the trailing newline, rather than polluting the loop
+    # with logic to work out if we're on the final loop iteration
+    return content.strip("\n")
 
 
-def to_string(structure: Class) -> str:
-    content = declaration(structure.name, structure.parents)
+def to_string(structure: Class, indent: str = " " * DEFAULT_INDENT_WIDTH) -> str:
+    content = declaration(structure.name, structure.parents, indent)
     content += "\n"
-    content += docstring(structure.docstring) if docstring else ""
-    content += attributes(structure.attributes)
+    content += docstring(structure.docstring, indent) if docstring else ""
+    content += attributes(structure.attributes, indent)
     content += "\n"
-    content += methods(structure.methods)
+    content += classes(structure.classes, indent)
+    content += methods(structure.methods, indent)
 
     return content

src/classify/templates/class.html

@@ -0,0 +1,65 @@
+<h1>class {{ klass.name }}</h1>
+
+{% if klass.docstring %}
+<pre>{{ klass.docstring }}</pre>
+{% endif %}
+
+{% if klass.ancestors %}
+  <h2>Ancestors (MRO)</h2>
+  <ol>
+    {% for ancestor in klass.ancestors %}
+    <li>{{ ancestor }}</li>
+    {% endfor %}
+  </ol>
+{% endif %}
+
+{% if klass.attributes %}
+  <h2>Attributes</h2>
+  <table>
+    <thead>
+      <tr>
+        <th>&nbsp;</th>
+        <th>Defined in</th>
+      </tr>
+    </thead>
+    <tbody>
+      {% for name, attributes in klass.attributes.items() %}
+        {% for attribute in attributes %}
+          <tr>
+            <td>
+              <code class="attribute{% if not loop.last %} overridden{% endif %}"{% if not loop.last %} style="text-decoration:line-through"{% endif %}>
+                {{ name }} = {{ attribute.object|e }}
+              </code>
+            </td>
+            <td>{{ attribute.defining_class }}</td>
+          </tr>
+        {% endfor %}
+      {% endfor %}
+    </tbody>
+  </table>
+{% endif %}
+
+{% if klass.classes %}
+  <h2>Inner classes</h2>
+
+  {% for foo in klass.classes %}
+    {% with klass=foo %}
+    {% include "class.html" %}
+    {% endwith %}
+  {% endfor %}
+
+{% endif %}
+
+{% if klass.methods %}
+  <h2>Methods</h2>
+  {% for name, declarations in klass.methods.items() %}
+    {% for declaration in declarations %}
+      <div class="method">
+        <h3>def {{ name }}{{ declaration.arguments }}: [{{ declaration.defining_class }}]</h3>
+        <p>{{ declaration.docstring|e }}</p>
+        <p>Found on lines {{ declaration.lines.start }} to {{ declaration.lines.start+declaration.lines.total }} of {{ declaration.file }}</p>
+        <pre>{{ declaration.code }}</pre>
+      </div>
+    {% endfor %}
+  {% endfor %}
+{% endif %}

src/classify/templates/web.html

@@ -1,53 +1,17 @@
 <!DOCTYPE html>
 <html lang="en">
-<head>
+  <head>
     <meta charset="utf-8">
     <title>{{ klass.name }}</title>
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-</head>
-<body>
+  </head>
+  <body>
     <div class="container">
-        <article id="main">
-            {% if klass.attributes %}
-                <h2>Attributes</h2>
-                <table>
-                    <thead>
-                        <tr>
-                            <th>&nbsp;</th>
-                            <th>Defined in</th>
-                        </tr>
-                    </thead>
-                    <tbody>
-                        {% for name, attributes in klass.attributes.items() %}
-                        {% for attribute in attributes %}
-                        <tr>
-                            <td>
-                                <code class="attribute{% if not loop.last %} overridden{% endif %}"{% if not loop.last %} style="text-decoration:line-through"{% endif %}>
-                                    {{ name }} = {{ attribute.object|e }}
-                                </code>
-                            </td>
-                            <td>{{ attribute.defining_class }}</td>
-                        </tr>
-                        {% endfor %}
-                        {% endfor %}
-                    </tbody>
-                </table>
-            {% endif %}
+      <article id="main">
 
-            {% if klass.methods %}
-                <h2>Methods</h2>
-                {% for name, declarations in klass.methods.items() %}
-                    {% for declaration in declarations %}
-                    <div class="method">
-                        <h3>def {{ name }}{{ declaration.arguments }}: [{{ declaration.defining_class.__name__ }}]</h3>
-                        <p>{{ declaration.docstring|e }}</p>
-                        <p>Found on lines {{ declaration.lines.start }} to {{ declaration.lines.start+declaration.lines.total }} of {{ declaration.file }}</p>
-                        <pre>{{ declaration.code }}</pre>
-                    </div>
-                    {% endfor %}
-                {% endfor %}
-            {% endif %}
-        </article>
+        {% include "class.html" %}
+
+      </article>
     </div> <!-- /container -->
-</body>
+  </body>
 </html>

tests/conftest.py

@@ -1,6 +1,27 @@
 import pytest
 
-from classify.library import Class, Line, Method
+from classify.library import Attribute, Class, Line, Method
+
+
+def inner_class(name):
+    return Class(
+        name=name,
+        docstring="",
+        ancestors=[name],
+        parents=[],
+        attributes={
+            "abc": [
+                Attribute(
+                    name="abc",
+                    object="123",
+                    defining_class=name,
+                    value="123",
+                )
+            ]
+        },
+        classes=[],
+        methods={},
+    )
 
 
 def method(name, **kwargs):
@@ -18,14 +39,17 @@ def method(name, **kwargs):
 def dummy_class():
     return Class(
         name="MyClass",
+        docstring="",
+        ancestors=[],
+        parents=["ParentClass"],
+        attributes={},
+        classes=[
+            inner_class("Meta"),
+        ],
         methods={
             "one": [
                 method("one", defining_class="ParentClass"),
                 method("one", defining_class="MyClass"),
             ]
         },
-        docstring="",
-        ancestors=[],
-        parents=["ParentClass"],
-        attributes={},
     )

tests/renderers/test_string.py

@@ -2,4 +2,4 @@
 
 
 def test_docstring():
-    assert docstring("") == ""
+    assert docstring("", indent="    ") == ""

tests/test_library.py

@@ -12,6 +12,7 @@
         (
             DummyClass,
             [
+                "Meta",
                 "__init__",
                 "class_method",
                 "class_only_method",