webwidgets 1.0.0__tar.gz → 1.1.0__tar.gz

{webwidgets-1.0.0 → webwidgets-1.1.0}/.github/workflows/ci-full.yml

@@ -64,15 +64,14 @@ jobs:
       uses: actions/setup-python@v3
       with:
         python-version: ${{ matrix.python-version }}
-    - name: Install pytest
+    - name: Upgrading pip
       run: |
         python -c "import platform; print('OS', platform.system())"
         python -c "import sys; print('Python version', sys.version)"
         python -m pip install --upgrade pip
-        pip install pytest
     - name: Build and install
       run: |
-        pip install .
+        pip install .[dev]
         # Removing webwidgets directory so imports come from build
         rm -r webwidgets
     - name: Test with pytest

{webwidgets-1.0.0 → webwidgets-1.1.0}/.github/workflows/ci-quick.yml

@@ -59,16 +59,15 @@ jobs:
       uses: actions/setup-python@v3
       with:
         python-version: ${{ matrix.python-version }}
-    - name: Install pytest
+    - name: Upgrading pip
       run: |
         python -c "import sys; print('Python version', sys.version)"
         python -m pip install --upgrade pip
-        pip install pytest
     - name: Build and install
       run: |
         echo "Current directory:"
         ls -la
-        pip install .
+        pip install .[dev]
         # Removing webwidgets directory so imports come from build
         rm -r webwidgets
         echo "Removed webwidgets directory. New content:"

{webwidgets-1.0.0 → webwidgets-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webwidgets
-Version: 1.0.0
+Version: 1.1.0
 Summary: A Python package for designing web UIs.
 Project-URL: Source code, https://github.com/mlaasri/WebWidgets
 Author: mlaasri
@@ -9,6 +9,11 @@ Keywords: design,webui
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: numpy; extra == 'dev'
+Requires-Dist: pillow; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: selenium; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # WebWidgets

{webwidgets-1.0.0 → webwidgets-1.1.0}/pyproject.toml

@@ -21,6 +21,14 @@ classifiers = [
 [project.urls]
 "Source code" = "https://github.com/mlaasri/WebWidgets"
 
+[project.optional-dependencies]
+dev = [
+    "numpy",
+    "pillow",
+    "pytest",
+    "selenium"
+]
+
 [tool.hatch.version]
 path = "webwidgets/__init__.py"
 

{webwidgets-1.0.0 → webwidgets-1.1.0}/tests/compilation/test_css.py

@@ -14,8 +14,10 @@ import pytest
 from typing import Any, Dict, List
 from webwidgets.compilation.html.html_node import HTMLNode
 from webwidgets.compilation.html.html_tags import TextNode
-from webwidgets.compilation.css.css import compile_css, CSSRule, CompiledCSS, \
-    apply_css, default_rule_namer
+from webwidgets.compilation.css.css import apply_css, compile_css, CompiledCSS, \
+    default_class_namer
+from webwidgets.compilation.css.css_rule import ClassRule, CSSRule
+from webwidgets.compilation.css.sections import RuleSection
 
 
 class TestCompileCSS:
@@ -29,19 +31,20 @@ class TestCompileCSS:
         :return: List of the member variables of each :py:class:`CSSRule`.
         :rtype: Dict[int, Any]
         """
-        return [vars(rule) for rule in rules]
+        return [{a: getattr(rule, a) for a in ("selector", "declarations")}
+                for rule in rules]
 
     @staticmethod
-    def _serialize_mapping(mapping: Dict[int, List[CSSRule]]) -> Dict[int, List[str]]:
+    def _serialize_mapping(mapping: Dict[int, List[ClassRule]]) -> Dict[int, List[str]]:
         """Utility function to convert a :py:attr:`CompiledCSS.mapping` object
         into a dictionary that can be used in testing.
 
         :param mapping: :py:attr:`CompiledCSS.mapping` object.
-        :type mapping: Dict[int, List[CSSRule]]
-        :return: Dictionary mapping each node ID to the name of the rules that
-            achieve the same style.
+        :type mapping: Dict[int, List[ClassRule]]
+        :return: Dictionary mapping each node ID to the selectors of the rules
+            that achieve the same style.
         """
-        return {i: [r.name for r in rules] for i, rules in mapping.items()}
+        return {i: [r.selector for r in rules] for i, rules in mapping.items()}
 
     def test_argument_type(self):
         """Compares compilation when given a node object versus a list of
@@ -57,12 +60,12 @@ class TestCompileCSS:
 
         # Define expected compilation results
         expected_rules = [
-            {"name": "r0", "declarations": {"a": "5"}},
-            {"name": "r1", "declarations": {"b": "4"}}
+            {"selector": ".c0", "declarations": {"a": "5"}},
+            {"selector": ".c1", "declarations": {"b": "4"}}
         ]
         expected_mapping = {
-            id(tree): ['r0', 'r1'],
-            id(tree.children[0]): ['r0']
+            id(tree): ['.c0', '.c1'],
+            id(tree.children[0]): ['.c0']
         }
 
         # Compile tree as single node object
@@ -72,7 +75,7 @@ class TestCompileCSS:
         assert compiled_css.trees == [tree]
         assert [id(t) for t in compiled_css.trees] == [id(tree)]
         assert TestCompileCSS._serialize_rules(
-            compiled_css.rules) == expected_rules
+            compiled_css.core.rules) == expected_rules
         assert TestCompileCSS._serialize_mapping(
             compiled_css.mapping) == expected_mapping
 
@@ -83,7 +86,7 @@ class TestCompileCSS:
         assert compiled_css2.trees == [tree]
         assert [id(t) for t in compiled_css2.trees] == [id(tree)]
         assert TestCompileCSS._serialize_rules(
-            compiled_css2.rules) == expected_rules
+            compiled_css2.core.rules) == expected_rules
         assert TestCompileCSS._serialize_mapping(
             compiled_css2.mapping) == expected_mapping
 
@@ -103,16 +106,16 @@ class TestCompileCSS:
 
         # Check that the rules are correctly generated
         expected_rules = [
-            {"name": "r0", "declarations": {"color": "blue"}},
-            {"name": "r1", "declarations": {"margin": "0"}},
-            {"name": "r2", "declarations": {"padding": "0"}}
+            {"selector": ".c0", "declarations": {"color": "blue"}},
+            {"selector": ".c1", "declarations": {"margin": "0"}},
+            {"selector": ".c2", "declarations": {"padding": "0"}}
         ]
         assert TestCompileCSS._serialize_rules(
-            compiled_css.rules) == expected_rules
+            compiled_css.core.rules) == expected_rules
 
         # Check that the mapping is correctly generated
-        expected_mapping = {id(node1): ['r1', 'r2'], id(
-            node2): ['r0', 'r1'], id(node3): ['r1', 'r2']}
+        expected_mapping = {id(node1): ['.c1', '.c2'], id(
+            node2): ['.c0', '.c1'], id(node3): ['.c1', '.c2']}
         assert TestCompileCSS._serialize_mapping(
             compiled_css.mapping) == expected_mapping
 
@@ -137,19 +140,19 @@ class TestCompileCSS:
 
         # Check that the rules are correctly generated
         expected_rules = [
-            {"name": "r0", "declarations": {"color": "blue"}},
-            {"name": "r1", "declarations": {"margin": "0"}},
-            {"name": "r2", "declarations": {"margin": "5"}},
-            {"name": "r3", "declarations": {"padding": "0"}}
+            {"selector": ".c0", "declarations": {"color": "blue"}},
+            {"selector": ".c1", "declarations": {"margin": "0"}},
+            {"selector": ".c2", "declarations": {"margin": "5"}},
+            {"selector": ".c3", "declarations": {"padding": "0"}}
         ]
         assert TestCompileCSS._serialize_rules(
-            compiled_css.rules) == expected_rules
+            compiled_css.core.rules) == expected_rules
 
         # Check that the mapping is correctly generated
         expected_mapping = {
-            id(tree): ['r1', 'r3'],
-            id(tree.children[0]): ['r0', 'r2'],
-            id(tree.children[1]): ['r0', 'r3'],
+            id(tree): ['.c1', '.c3'],
+            id(tree.children[0]): ['.c0', '.c2'],
+            id(tree.children[1]): ['.c0', '.c3'],
             id(tree.children[0].children[0]): [],
             id(tree.children[1].children[0]): []
         }
@@ -181,20 +184,20 @@ class TestCompileCSS:
 
         # Check that the rules are correctly generated
         expected_rules = [
-            {"name": "r0", "declarations": {"color": "red"}},
-            {"name": "r1", "declarations": {"margin": "10"}},
-            {"name": "r2", "declarations": {"margin": "5"}},
-            {"name": "r3", "declarations": {"padding": "0"}}
+            {"selector": ".c0", "declarations": {"color": "red"}},
+            {"selector": ".c1", "declarations": {"margin": "10"}},
+            {"selector": ".c2", "declarations": {"margin": "5"}},
+            {"selector": ".c3", "declarations": {"padding": "0"}}
         ]
         assert TestCompileCSS._serialize_rules(
-            compiled_css.rules) == expected_rules
+            compiled_css.core.rules) == expected_rules
 
         # Check that the mapping is correctly generated
         expected_mapping = {
-            id(tree1): ['r1', 'r3'],
-            id(tree1.children[0]): ['r0'],
-            id(tree2): ['r2', 'r3'],
-            id(tree2.children[0]): ['r1']
+            id(tree1): ['.c1', '.c3'],
+            id(tree1.children[0]): ['.c0'],
+            id(tree2): ['.c2', '.c3'],
+            id(tree2.children[0]): ['.c1']
         }
         assert TestCompileCSS._serialize_mapping(
             compiled_css.mapping) == expected_mapping
@@ -211,14 +214,14 @@ class TestCompileCSS:
         )
         compiled_css = compile_css(tree)
         expected_rules = [
-            {"name": "r0", "declarations": {"a": "10"}},
-            {"name": "r1", "declarations": {"a": "5"}},
-            {"name": "r2", "declarations": {"b": "10"}},
-            {"name": "r3", "declarations": {"b": "4"}},
-            {"name": "r4", "declarations": {"c": "5"}},
+            {"selector": ".c0", "declarations": {"a": "10"}},
+            {"selector": ".c1", "declarations": {"a": "5"}},
+            {"selector": ".c2", "declarations": {"b": "10"}},
+            {"selector": ".c3", "declarations": {"b": "4"}},
+            {"selector": ".c4", "declarations": {"c": "5"}},
         ]
         assert TestCompileCSS._serialize_rules(
-            compiled_css.rules) == expected_rules
+            compiled_css.core.rules) == expected_rules
 
     def test_duplicate_node(self):
         """Test that adding the same node twice does not impact compilation"""
@@ -231,20 +234,20 @@ class TestCompileCSS:
             ]
         )
         expected_rules = [
-            {"name": "r0", "declarations": {"a": "5"}},
-            {"name": "r1", "declarations": {"b": "10"}},
-            {"name": "r2", "declarations": {"b": "4"}}
+            {"selector": ".c0", "declarations": {"a": "5"}},
+            {"selector": ".c1", "declarations": {"b": "10"}},
+            {"selector": ".c2", "declarations": {"b": "4"}}
         ]
         expected_mapping = {
-            id(tree): ['r0', 'r2'],
-            id(tree.children[0]): ['r0'],
-            id(tree.children[1]): ['r1']
+            id(tree): ['.c0', '.c2'],
+            id(tree.children[0]): ['.c0'],
+            id(tree.children[1]): ['.c1']
         }
         compiled_css = compile_css([tree])
         assert compiled_css.trees == [tree]
         assert [id(t) for t in compiled_css.trees] == [id(tree)]
         assert TestCompileCSS._serialize_rules(
-            compiled_css.rules) == expected_rules
+            compiled_css.core.rules) == expected_rules
         assert TestCompileCSS._serialize_mapping(
             compiled_css.mapping) == expected_mapping
 
@@ -256,21 +259,21 @@ class TestCompileCSS:
         assert [id(t) for t in compiled_css2.trees] == [
             id(tree), id(tree.children[0])]
         assert TestCompileCSS._serialize_rules(
-            compiled_css2.rules) == expected_rules
+            compiled_css2.core.rules) == expected_rules
         assert TestCompileCSS._serialize_mapping(
             compiled_css2.mapping) == expected_mapping
 
-    @pytest.mark.parametrize("rule_namer, names", [
-        (lambda _, i: f"rule{i}", ["rule0", "rule1", "rule2"]),
-        (lambda _, i: f"rule-{i + 1}", ["rule-1", "rule-2", "rule-3"]),
+    @pytest.mark.parametrize("class_namer, selectors", [
+        (lambda _, i: f"rule{i}", [".rule0", ".rule1", ".rule2"]),
+        (lambda _, i: f"rule-{i + 1}", [".rule-1", ".rule-2", ".rule-3"]),
         (lambda r, i: f"{list(r[i].declarations.items())[0][0]}{i}", [
-            "az0", "bz1", "bz2"]),
+            ".az0", ".bz1", ".bz2"]),
         (lambda r, i: f"{list(r[i].declarations.items())[0][0][0]}{i}", [
-            "a0", "b1", "b2"]),
-        (lambda r, i: f"r{list(r[i].declarations.items())[0][1]}-{i}", [
-            "r10-1", "r4-2", "r5-0"]),
+            ".a0", ".b1", ".b2"]),
+        (lambda r, i: f"c{list(r[i].declarations.items())[0][1]}-{i}", [
+            ".c10-1", ".c4-2", ".c5-0"]),
     ])
-    def test_custom_rule_names(self, rule_namer, names):
+    def test_custom_class_names(self, class_namer, selectors):
         tree = HTMLNode(
             style={"az": "5", "bz": "4"},
             children=[
@@ -278,39 +281,43 @@ class TestCompileCSS:
                 HTMLNode(style={"bz": "10"}),
             ]
         )
-        compiled_css = compile_css(tree, rule_namer=rule_namer)
-        assert [r.name for r in compiled_css.rules] == names
+        compiled_css = compile_css(tree, class_namer=class_namer)
+        assert [r.selector for r in compiled_css.core.rules] == selectors
 
 
 class TestCompiledCSS:
-    def test_export_custom_compiled_css(self):
-        rules = [
-            CSSRule(name="r0", declarations={"margin": "0", "padding": "0"}),
-            CSSRule(name="r1", declarations={"color": "blue"}),
-            CSSRule(name="r2", declarations={
+    def test_export_custom_compiled_css(self, wrap_core_css):
+        core = RuleSection(
+            rules=[
+                CSSRule(selector=".c0", declarations={
+                    "margin": "0", "padding": "0"}),
+                CSSRule(selector=".c1", declarations={"color": "blue"}),
+                CSSRule(selector=".c2", declarations={
                     "background-color": "white", "font-size": "16px"})
-        ]
+            ],
+            title="Core"
+        )
         compiled_css = CompiledCSS(trees=None,
-                                   rules=rules,
+                                   core=core,
                                    mapping=None)
-        expected_css = '\n'.join([
-            ".r0 {",
+        expected_core_css = '\n'.join([
+            ".c0 {",
             "    margin: 0;",
             "    padding: 0;",
             "}",
             "",
-            ".r1 {",
+            ".c1 {",
             "    color: blue;",
             "}",
             "",
-            ".r2 {",
+            ".c2 {",
             "    background-color: white;",
             "    font-size: 16px;",
             "}"
         ])
-        assert compiled_css.to_css() == expected_css
+        assert compiled_css.to_css() == wrap_core_css(expected_core_css)
 
-    def test_export_real_compiled_css(self):
+    def test_export_real_compiled_css(self, wrap_core_css):
         tree = HTMLNode(
             style={"margin": "0", "padding": "0"},
             children=[
@@ -319,33 +326,33 @@ class TestCompiledCSS:
             ]
         )
         compiled_css = compile_css(tree)
-        expected_css = '\n'.join([
-            ".r0 {",
+        expected_core_css = '\n'.join([
+            ".c0 {",
             "    color: blue;",
             "}",
             "",
-            ".r1 {",
+            ".c1 {",
             "    color: green;",
             "}",
             "",
-            ".r2 {",
+            ".c2 {",
             "    margin: 0;",
             "}",
             "",
-            ".r3 {",
+            ".c3 {",
             "    padding: 0;",
             "}"
         ])
-        assert compiled_css.to_css() == expected_css
+        assert compiled_css.to_css() == wrap_core_css(expected_core_css)
 
-    def test_export_empty_style(self):
+    def test_export_empty_style(self, wrap_core_css):
         node = HTMLNode()
         css = compile_css(node).to_css()
-        assert css == ""
+        assert css == wrap_core_css("")
         other_css = CompiledCSS(trees=None,
-                                rules={},
+                                core=RuleSection(title="Core"),
                                 mapping=None).to_css()
-        assert other_css == ""
+        assert other_css == wrap_core_css("")
 
     def test_export_invalid_style(self):
         node = HTMLNode(style={"marg!in": "0", "padding": "0"})
@@ -354,29 +361,29 @@ class TestCompiledCSS:
             compiled_css.to_css()
 
     @pytest.mark.parametrize("indent_size", [0, 2, 4, 8])
-    def test_css_indentation(self, indent_size):
+    def test_css_indentation(self, indent_size, wrap_core_css):
         node = HTMLNode(style={"a": "0", "b": "1"})
-        expected_css = '\n'.join([
-            ".r0 {",
+        expected_core_css = '\n'.join([
+            ".c0 {",
             f"{' ' * indent_size}a: 0;",
             "}",
             "",
-            ".r1 {",
+            ".c1 {",
             f"{' ' * indent_size}b: 1;",
             "}"
         ])
         css = compile_css(node).to_css(indent_size=indent_size)
-        assert css == expected_css
+        assert css == wrap_core_css(expected_core_css, indent_size=indent_size)
 
 
 class TestApplyCSS:
     @pytest.mark.parametrize("class_in, class_out", [
-        (None, "r0 r1"),  # No class attribute
-        ("", "r0 r1"),  # Empty class
-        ("z", "z r0 r1"),  # Existing class
-        ("r1", "r1 r0"),  # Existing rule
-        ("z r1", "z r1 r0"),  # Existing class and rule
-        ("r1 z", "r1 z r0")  # Existing rule and class
+        (None, "c0 c1"),  # No class attribute
+        ("", "c0 c1"),  # Empty class
+        ("z", "z c0 c1"),  # Existing class
+        ("c1", "c1 c0"),  # Existing rule
+        ("z c1", "z c1 c0"),  # Existing class and rule
+        ("c1 z", "c1 z c0")  # Existing rule and class
     ])
     def test_apply_css_to_node(self, class_in, class_out):
         tree = HTMLNode(attributes=None if class_in is None else {"class": class_in},
@@ -386,22 +393,22 @@ class TestApplyCSS:
         assert tree.to_html() == f'<htmlnode class="{class_out}"></htmlnode>'
 
     @pytest.mark.parametrize("cl1_in, cl1_out", [
-        (None, "r2 r3"),  # No class attribute
-        ("", "r2 r3"),  # Empty class
-        ("c", "c r2 r3"),  # Existing class
-        ("r3", "r3 r2"),  # Existing rule
-        ("c r3", "c r3 r2"),  # Existing class and rule
-        ("r3 c", "r3 c r2"),  # Existing rule and class
-        ("rr3", "rr3 r2 r3")  # Rule decoy
+        (None, "c2 c3"),  # No class attribute
+        ("", "c2 c3"),  # Empty class
+        ("c", "c c2 c3"),  # Existing class
+        ("c3", "c3 c2"),  # Existing rule
+        ("c c3", "c c3 c2"),  # Existing class and rule
+        ("c3 c", "c3 c c2"),  # Existing rule and class
+        ("rc3", "rc3 c2 c3")  # Rule decoy
     ])
     @pytest.mark.parametrize("cl2_in, cl2_out", [
-        (None, "r1 r2"),  # No class attribute
-        ("", "r1 r2"),  # Empty class
-        ("z", "z r1 r2"),  # Existing class
-        ("r1", "r1 r2"),  # Existing rule
-        ("z r1", "z r1 r2"),  # Existing class and rule
-        ("r1 z", "r1 z r2"),  # Existing rule and class
-        ("rr1", "rr1 r1 r2")  # Rule decoy
+        (None, "c1 c2"),  # No class attribute
+        ("", "c1 c2"),  # Empty class
+        ("z", "z c1 c2"),  # Existing class
+        ("c1", "c1 c2"),  # Existing rule
+        ("z c1", "z c1 c2"),  # Existing class and rule
+        ("c1 z", "c1 z c2"),  # Existing rule and class
+        ("cc1", "cc1 c1 c2")  # Rule decoy
     ])
     @pytest.mark.parametrize("mix", [False, True])
     def test_apply_css_to_tree(self, cl1_in, cl1_out, cl2_in, cl2_out, mix):
@@ -419,22 +426,22 @@ class TestApplyCSS:
 
         # Compiling and applying CSS to the tree
         compiled_css = compile_css(tree)
-        assert TestCompileCSS._serialize_rules(compiled_css.rules) == [
-            {"name": "r0", "declarations": {"color": "blue"}},
-            {"name": "r1", "declarations": {"color": "green"}},
-            {"name": "r2", "declarations": {"margin": "0"}},
-            {"name": "r3", "declarations": {"padding": "0"}}
+        assert TestCompileCSS._serialize_rules(compiled_css.core.rules) == [
+            {"selector": ".c0", "declarations": {"color": "blue"}},
+            {"selector": ".c1", "declarations": {"color": "green"}},
+            {"selector": ".c2", "declarations": {"margin": "0"}},
+            {"selector": ".c3", "declarations": {"padding": "0"}}
         ]
         apply_css(compiled_css, tree)
 
         # Checking the tree's new classes
         assert tree.attributes["class"] == cl1_out
-        assert tree.children[0].attributes["class"] == "r0 r2"
+        assert tree.children[0].attributes["class"] == "c0 c2"
         assert tree.children[1].attributes["class"] == cl2_out
 
         # Checking the final HTML code
-        mix_node = '<textnode class="r0 r2">a</textnode>' if mix else \
-            '<htmlnode class="r0 r2"></htmlnode>'
+        mix_node = '<textnode class="c0 c2">a</textnode>' if mix else \
+            '<htmlnode class="c0 c2"></htmlnode>'
         expected_html = '\n'.join([
             f'<htmlnode class="{cl1_out}">',
             f'    {mix_node}',
@@ -453,7 +460,7 @@ class TestApplyCSS:
         )
         html_before = tree.to_html()
         compiled_css = compile_css(tree)
-        assert compiled_css.rules == []
+        assert compiled_css.core.rules == []
         apply_css(compiled_css, tree)
         html_after = tree.to_html()
 
@@ -486,24 +493,24 @@ class TestApplyCSS:
 
         # Checking the tree's new classes
         assert "class" not in tree.attributes
-        assert tree.children[0].attributes["class"] == "r0 r1"
+        assert tree.children[0].attributes["class"] == "c0 c1"
         assert tree.children[1].attributes["class"] == "z"
 
         # Checking the final HTML code
         expected_html = '\n'.join([
             '<htmlnode>',
-            '    <textnode class="r0 r1">a</textnode>',
+            '    <textnode class="c0 c1">a</textnode>',
             '    <htmlnode class="z"></htmlnode>',
             '</htmlnode>'
         ])
         assert tree.to_html() == expected_html
 
     @pytest.mark.parametrize("class_in, class_out", [
-        (None, "r0 r1"),
-        ("", "r0 r1"),
-        ("z", "z r0 r1"),
-        ("r0", "r0 r1"),
-        ("r1", "r1 r0"),
+        (None, "c0 c1"),
+        ("", "c0 c1"),
+        ("z", "z c0 c1"),
+        ("c0", "c0 c1"),
+        ("c1", "c1 c0"),
     ])
     def test_apply_css_multiple_times(self, class_in, class_out):
         tree = HTMLNode(style={"a": "0", "b": "1"}) if class_in is None else \
@@ -533,20 +540,20 @@ class TestApplyCSS:
 
 
 class TestDefaultRuleNamer:
-    def test_default_rule_namer(self):
-        rules = [CSSRule(None, {"color": "red"}),
-                 CSSRule(None, {"margin": "0"})]
+    def test_default_class_namer(self):
+        rules = [ClassRule(None, {"color": "red"}),
+                 ClassRule(None, {"margin": "0"})]
         for i, rule in enumerate(rules):
-            rule.name = default_rule_namer(rules=rules, index=i)
-        assert rules[0].name == "r0"
-        assert rules[1].name == "r1"
+            rule.name = default_class_namer(rules=rules, index=i)
+        assert rules[0].name == "c0"
+        assert rules[1].name == "c1"
 
-    def test_default_rule_namer_override(self):
-        rules = [CSSRule("first", {"color": "red"}),
-                 CSSRule("second", {"margin": "0"})]
+    def test_default_class_namer_override(self):
+        rules = [ClassRule("first", {"color": "red"}),
+                 ClassRule("second", {"margin": "0"})]
         assert rules[0].name == "first"
         assert rules[1].name == "second"
         for i, rule in enumerate(rules):
-            rule.name = default_rule_namer(rules=rules, index=i)
-        assert rules[0].name == "r0"
-        assert rules[1].name == "r1"
+            rule.name = default_class_namer(rules=rules, index=i)
+        assert rules[0].name == "c0"
+        assert rules[1].name == "c1"