moz-fluent-linter 0.4.7__tar.gz → 0.4.8__tar.gz

{moz_fluent_linter-0.4.7/src/moz_fluent_linter.egg-info → moz_fluent_linter-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: moz-fluent-linter
-Version: 0.4.7
+Version: 0.4.8
 Summary: Linter package used to check Fluent files
 Home-page: https://github.com/mozilla-l10n/moz-fluent-linter
 Author: Francesco Lodolo
@@ -18,6 +18,7 @@ License-File: LICENSE
 Requires-Dist: fluent.syntax~=0.19.0
 Requires-Dist: pyyaml
 Requires-Dist: six
+Dynamic: license-file
 
 # Fluent Linter
 
@@ -41,7 +42,7 @@ Using [pre-commit](https://pre-commit.com/), add this to the `.pre-commit-config
 ```yaml
 repos:
   - repo: https://github.com/mozilla-l10n/moz-fluent-linter
-    rev: v0.4.7
+    rev: v0.4.8
     hooks:
       - id: fluent_linter
         files: \.ftl$

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/README.md

@@ -20,7 +20,7 @@ Using [pre-commit](https://pre-commit.com/), add this to the `.pre-commit-config
 ```yaml
 repos:
   - repo: https://github.com/mozilla-l10n/moz-fluent-linter
-    rev: v0.4.7
+    rev: v0.4.8
     hooks:
       - id: fluent_linter
         files: \.ftl$

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = moz-fluent-linter
-version = 0.4.7
+version = 0.4.8
 author = Francesco Lodolo
 author_email = flod@mozilla.com
 description = Linter package used to check Fluent files

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/setup.py

@@ -1,4 +1,5 @@
 from setuptools import setup
 
+
 if __name__ == "__main__":
     setup()

moz_fluent_linter-0.4.8/src/fluent_linter/__init__.py

@@ -0,0 +1 @@
+version = "0.4.8"

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/src/fluent_linter/linter.py

@@ -5,15 +5,19 @@
 # This script is largely based on the Fluent Linter used in mozilla-central
 # https://firefox-source-docs.mozilla.org/code-quality/lint/linters/fluent-lint.html
 
-from fluent.syntax import ast, parse, serializer, visitor
-from html.parser import HTMLParser
 import argparse
 import bisect
 import os
 import re
 import sys
+
+from html.parser import HTMLParser
+
 import yaml
 
+from fluent.syntax import ast, parse, serializer, visitor
+
+
 try:
     from fluent_linter import version
 except Exception:
@@ -160,31 +164,42 @@ class Linter(visitor.Visitor):
                     f" hard-coded brand names ({', '.join(found_brands)})",
                 )
 
-        if self.apostrophe_re.search(cleaned_str):
-            if not self.exclude_message("TE01", message_id):
-                self.add_error(
-                    node,
-                    message_id,
-                    "TE01",
-                    "Strings with apostrophes should use foo\u2019s instead of foo's.",
-                )
-        if self.incorrect_apostrophe_re.search(cleaned_str):
-            if not self.exclude_message("TE02", message_id):
-                self.add_error(
-                    node,
-                    message_id,
-                    "TE02",
-                    "Strings with apostrophes should use foo\u2019s instead of foo\u2018s.",
-                )
-        if self.single_quote_re.search(cleaned_str):
-            if not self.exclude_message("TE03", message_id):
-                self.add_error(
-                    node,
-                    message_id,
-                    "TE03",
-                    "Single-quoted strings should use Unicode \u2018foo\u2019 instead of 'foo'.",
-                )
-        if self.double_quote_re.search(cleaned_str):
+        if (
+            self.config.get("TE01", {}).get("enabled", True)
+            and self.apostrophe_re.search(cleaned_str)
+            and not self.exclude_message("TE01", message_id)
+        ):
+            self.add_error(
+                node,
+                message_id,
+                "TE01",
+                "Strings with apostrophes should use foo\u2019s instead of foo's.",
+            )
+        if (
+            self.config.get("TE02", {}).get("enabled", True)
+            and self.incorrect_apostrophe_re.search(cleaned_str)
+            and not self.exclude_message("TE02", message_id)
+        ):
+            self.add_error(
+                node,
+                message_id,
+                "TE02",
+                "Strings with apostrophes should use foo\u2019s instead of foo\u2018s.",
+            )
+        if (
+            self.config.get("TE03", {}).get("enabled", True)
+            and self.single_quote_re.search(cleaned_str)
+            and not self.exclude_message("TE03", message_id)
+        ):
+            self.add_error(
+                node,
+                message_id,
+                "TE03",
+                "Single-quoted strings should use Unicode \u2018foo\u2019 instead of 'foo'.",
+            )
+        if self.config.get("TE04", {}).get(
+            "enabled", True
+        ) and self.double_quote_re.search(cleaned_str):
             # Ignore parameterized terms and other functions
             for regex in self.ftl_syntax_re:
                 cleaned_str = regex.sub("", cleaned_str)
@@ -198,15 +213,18 @@ class Linter(visitor.Visitor):
                     "TE04",
                     'Double-quoted strings should use Unicode \u201cfoo\u201d instead of "foo".',
                 )
-        if self.ellipsis_re.search(cleaned_str):
-            if not self.exclude_message("TE05", message_id):
-                self.add_error(
-                    node,
-                    message_id,
-                    "TE05",
-                    "Strings with an ellipsis should use the Unicode \u2026 character"
-                    " instead of three periods",
-                )
+        if (
+            self.config.get("TE05", {}).get("enabled", True)
+            and self.ellipsis_re.search(cleaned_str)
+            and not self.exclude_message("TE05", message_id)
+        ):
+            self.add_error(
+                node,
+                message_id,
+                "TE05",
+                "Strings with an ellipsis should use the Unicode \u2026 character"
+                " instead of three periods",
+            )
 
     def generic_visit(self, node):
         node_name = type(node).__name__
@@ -418,9 +436,9 @@ class Linter(visitor.Visitor):
             and not self.config["PS01"]["disabled"]
             and type(node.expression) not in [ast.SelectExpression]
         ):
-            if type(node.expression) == ast.VariableReference:
+            if isinstance(node.expression, ast.VariableReference):
                 placeable_name = f"${node.expression.id.name}"
-            elif type(node.expression) == ast.TermReference:
+            elif isinstance(node.expression, ast.TermReference):
                 placeable_name = f"-{node.expression.id.name}"
             else:
                 placeable_name = node.expression.id.name
@@ -455,7 +473,7 @@ class Linter(visitor.Visitor):
         # Store the variable used for the SelectExpression, excluding functions
         # like PLATFORM()
         if (
-            type(node.selector) == ast.VariableReference
+            isinstance(node.selector, ast.VariableReference)
             and node.selector.id.name not in self.state["variables"]
         ):
             self.state["variables"].append(node.selector.id.name)

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8/src/moz_fluent_linter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: moz-fluent-linter
-Version: 0.4.7
+Version: 0.4.8
 Summary: Linter package used to check Fluent files
 Home-page: https://github.com/mozilla-l10n/moz-fluent-linter
 Author: Francesco Lodolo
@@ -18,6 +18,7 @@ License-File: LICENSE
 Requires-Dist: fluent.syntax~=0.19.0
 Requires-Dist: pyyaml
 Requires-Dist: six
+Dynamic: license-file
 
 # Fluent Linter
 
@@ -41,7 +42,7 @@ Using [pre-commit](https://pre-commit.com/), add this to the `.pre-commit-config
 ```yaml
 repos:
   - repo: https://github.com/mozilla-l10n/moz-fluent-linter
-    rev: v0.4.7
+    rev: v0.4.8
     hooks:
       - id: fluent_linter
         files: \.ftl$

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/tests/test_banned_words.py

@@ -1,16 +1,18 @@
 import unittest
-from src.fluent_linter import linter
+
 from fluent.syntax import parse
 
+from src.fluent_linter import linter
+
 
 class TestBannedWords(unittest.TestCase):
     def checkContent(self, config, content):
-        l = linter.Linter(
+        ftl_linter = linter.Linter(
             "file.ftl", "root", config, content, linter.get_offsets_and_lines(content)
         )
-        l.visit(parse(content))
+        ftl_linter.visit(parse(content))
 
-        return l.results
+        return ftl_linter.results
 
     def testCO01(self):
         content = """

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/tests/test_brands.py

@@ -1,16 +1,18 @@
 import unittest
-from src.fluent_linter import linter
+
 from fluent.syntax import parse
 
+from src.fluent_linter import linter
+
 
 class TestBrands(unittest.TestCase):
     def checkContent(self, config, content):
-        l = linter.Linter(
+        ftl_linter = linter.Linter(
             "file.ftl", "root", config, content, linter.get_offsets_and_lines(content)
         )
-        l.visit(parse(content))
+        ftl_linter.visit(parse(content))
 
-        return l.results
+        return ftl_linter.results
 
     def testCO01(self):
         content = """
@@ -82,7 +84,6 @@ good-account2 = Set up your { -brand-short-name } Account.
 
         config = {"CO01": {"enabled": True, "brands": ["Monitor"], "exclusions": {}}}
         results = self.checkContent(config, content)
-        print("\n".join(results))
         self.assertEqual(len(results), 1)
         self.assertTrue("bad-monitor" in results[0])
         self.assertTrue("good-monitor" not in results[0])

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/tests/test_comments.py

@@ -1,16 +1,18 @@
 import unittest
-from src.fluent_linter import linter
+
 from fluent.syntax import parse
 
+from src.fluent_linter import linter
+
 
 class TestComments(unittest.TestCase):
     def checkContent(self, config, content):
-        l = linter.Linter(
+        ftl_linter = linter.Linter(
             "path", "root", config, content, linter.get_offsets_and_lines(content)
         )
-        l.visit(parse(content))
+        ftl_linter.visit(parse(content))
 
-        return l.results
+        return ftl_linter.results
 
     def testGC01(self):
         content = """

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/tests/test_comments_variables.py

@@ -1,16 +1,18 @@
 import unittest
-from src.fluent_linter import linter
+
 from fluent.syntax import parse
 
+from src.fluent_linter import linter
+
 
 class TestCommentVariables(unittest.TestCase):
     def checkContent(self, config, content):
-        l = linter.Linter(
+        ftl_linter = linter.Linter(
             "path", "root", config, content, linter.get_offsets_and_lines(content)
         )
-        l.visit(parse(content))
+        ftl_linter.visit(parse(content))
 
-        return l.results
+        return ftl_linter.results
 
     def testVC01(self):
         content = """

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/tests/test_ids.py

@@ -1,16 +1,18 @@
 import unittest
-from src.fluent_linter import linter
+
 from fluent.syntax import parse
 
+from src.fluent_linter import linter
+
 
 class TestIDs(unittest.TestCase):
     def checkContent(self, path, root, config, content):
-        l = linter.Linter(
+        ftl_linter = linter.Linter(
             path, root, config, content, linter.get_offsets_and_lines(content)
         )
-        l.visit(parse(content))
+        ftl_linter.visit(parse(content))
 
-        return l.results
+        return ftl_linter.results
 
     def testID01(self):
         content = """

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/tests/test_placeable_style.py

@@ -1,16 +1,18 @@
 import unittest
-from src.fluent_linter import linter
+
 from fluent.syntax import parse
 
+from src.fluent_linter import linter
+
 
 class TestPlaceableStyle(unittest.TestCase):
     def checkContent(self, config, content):
-        l = linter.Linter(
+        ftl_linter = linter.Linter(
             "path", "root", config, content, linter.get_offsets_and_lines(content)
         )
-        l.visit(parse(content))
+        ftl_linter.visit(parse(content))
 
-        return l.results
+        return ftl_linter.results
 
     def testPS01_valid(self):
         content = """

{moz_fluent_linter-0.4.7 → moz_fluent_linter-0.4.8}/tests/test_syntax.py

@@ -1,16 +1,18 @@
 import unittest
-from src.fluent_linter import linter
+
 from fluent.syntax import parse
 
+from src.fluent_linter import linter
+
 
 class TestSyntax(unittest.TestCase):
     def checkContent(self, config, content):
-        l = linter.Linter(
+        ftl_linter = linter.Linter(
             "path", "root", config, content, linter.get_offsets_and_lines(content)
         )
-        l.visit(parse(content))
+        ftl_linter.visit(parse(content))
 
-        return l.results
+        return ftl_linter.results
 
     def testSY01(self):
         content = """

moz_fluent_linter-0.4.8/tests/test_typography.py

@@ -0,0 +1,222 @@
+import unittest
+
+from fluent.syntax import parse
+
+from src.fluent_linter import linter
+
+
+class TestTypography(unittest.TestCase):
+    def checkContent(self, config, content):
+        ftl_linter = linter.Linter(
+            "path", "root", config, content, linter.get_offsets_and_lines(content)
+        )
+        ftl_linter.visit(parse(content))
+
+        return ftl_linter.results
+
+    def testTE01(self):
+        content = """
+foo = bar's bar
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE01" in results[0])
+        self.assertTrue("foo" in results[0])
+
+        # Check exclusions
+        config = {"TE01": {"exclusions": {"messages": ["foo"]}}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+        content = """
+foo = bar ' bar
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 0)
+
+    def testTE02(self):
+        content = """
+foo = bar‘s bar
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE02" in results[0])
+        self.assertTrue("foo" in results[0])
+
+        # Check exclusions
+        config = {"TE02": {"exclusions": {"messages": ["foo"]}}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+        content = """
+foo = bar ‘ bar
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 0)
+
+    def testTE03(self):
+        content = """
+foo = bar 'bar' bar
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 2)
+        self.assertTrue("TE01" in results[0])
+        self.assertTrue("TE03" in results[1])
+        self.assertTrue("foo" in results[0])
+
+        # Check exclusions
+        config = {
+            "TE01": {"exclusions": {"messages": ["foo"]}},
+            "TE03": {"exclusions": {"messages": ["foo"]}},
+        }
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+    def testTE04(self):
+        content = """
+foo = bar "bar" bar
+# This shouldn't trigger an error
+foo1 = { -someterm(capitalization: "uppercase") }
+foo-datetime = Test: { DATETIME($timeChanged, day: "numeric", month: "long", year: "numeric") }
+foo-number = { NUMBER($mem, maxFractionalUnits: 2) } MB
+foo-empty = { "" }
+foo-space = { "" } test
+foo-curly1 = { "{" } test
+foo-curly2 = { "}" } test
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE04" in results[0])
+        self.assertTrue("foo" in results[0])
+
+        # Check exclusions
+        config = {"TE04": {"exclusions": {"messages": ["foo"]}}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+    def testTE05(self):
+        content = """
+foo = bar...
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE05" in results[0])
+
+        # Check exclusions
+        config = {"TE05": {"exclusions": {"messages": ["foo"]}}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+        content = """
+foo = bar…
+"""
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 0)
+
+    def testTE01Disabled(self):
+        """Test that TE01 can be disabled with enabled: false"""
+        content = """
+foo = bar's bar
+"""
+        # Rule enabled by default - should trigger error
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE01" in results[0])
+
+        # Rule explicitly disabled - should not trigger error
+        config = {"TE01": {"enabled": False}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+        # Rule explicitly enabled - should trigger error
+        config = {"TE01": {"enabled": True}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE01" in results[0])
+
+    def testTE02Disabled(self):
+        """Test that TE02 can be disabled with enabled: false"""
+        content = """
+foo = bar‘s bar
+"""
+        # Rule enabled by default - should trigger error
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE02" in results[0])
+
+        # Rule explicitly disabled - should not trigger error
+        config = {"TE02": {"enabled": False}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+        # Rule explicitly enabled - should trigger error
+        config = {"TE02": {"enabled": True}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE02" in results[0])
+
+    def testTE03Disabled(self):
+        """Test that TE03 can be disabled with enabled: false"""
+        content = """
+foo = bar 'test' bar
+"""
+        # Rule enabled by default - should trigger errors (TE01 and TE03)
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 2)
+        self.assertTrue("TE01" in results[0])
+        self.assertTrue("TE03" in results[1])
+
+        # TE03 explicitly disabled - should only get TE01 error
+        config = {"TE03": {"enabled": False}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE01" in results[0])
+
+        # TE03 explicitly enabled - should get both errors
+        config = {"TE03": {"enabled": True}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 2)
+        self.assertTrue("TE01" in results[0])
+        self.assertTrue("TE03" in results[1])
+
+    def testTE04Disabled(self):
+        """Test that TE04 can be disabled with enabled: false"""
+        content = """
+foo = bar "test" bar
+"""
+        # Rule enabled by default - should trigger error
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE04" in results[0])
+
+        # Rule explicitly disabled - should not trigger error
+        config = {"TE04": {"enabled": False}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+        # Rule explicitly enabled - should trigger error
+        config = {"TE04": {"enabled": True}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE04" in results[0])
+
+    def testTE05Disabled(self):
+        """Test that TE05 can be disabled with enabled: false"""
+        content = """
+foo = bar...
+"""
+        # Rule enabled by default - should trigger error
+        results = self.checkContent({}, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE05" in results[0])
+
+        # Rule explicitly disabled - should not trigger error
+        config = {"TE05": {"enabled": False}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 0)
+
+        # Rule explicitly enabled - should trigger error
+        config = {"TE05": {"enabled": True}}
+        results = self.checkContent(config, content)
+        self.assertEqual(len(results), 1)
+        self.assertTrue("TE05" in results[0])

moz_fluent_linter-0.4.7/src/fluent_linter/__init__.py

@@ -1 +0,0 @@
-version = "0.4.7"

moz_fluent_linter-0.4.7/tests/test_typography.py

@@ -1,112 +0,0 @@
-import unittest
-from src.fluent_linter import linter
-from fluent.syntax import parse
-
-
-class TestTypography(unittest.TestCase):
-    def checkContent(self, config, content):
-        l = linter.Linter(
-            "path", "root", config, content, linter.get_offsets_and_lines(content)
-        )
-        l.visit(parse(content))
-
-        return l.results
-
-    def testTE01(self):
-        content = """
-foo = bar's bar
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 1)
-        self.assertTrue("TE01" in results[0])
-        self.assertTrue("foo" in results[0])
-
-        # Check exclusions
-        config = {"TE01": {"exclusions": {"messages": ["foo"]}}}
-        results = self.checkContent(config, content)
-        self.assertEqual(len(results), 0)
-
-        content = """
-foo = bar ' bar
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 0)
-
-    def testTE02(self):
-        content = """
-foo = bar‘s bar
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 1)
-        self.assertTrue("TE02" in results[0])
-        self.assertTrue("foo" in results[0])
-
-        # Check exclusions
-        config = {"TE02": {"exclusions": {"messages": ["foo"]}}}
-        results = self.checkContent(config, content)
-        self.assertEqual(len(results), 0)
-
-        content = """
-foo = bar ‘ bar
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 0)
-
-    def testTE03(self):
-        content = """
-foo = bar 'bar' bar
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 2)
-        self.assertTrue("TE01" in results[0])
-        self.assertTrue("TE03" in results[1])
-        self.assertTrue("foo" in results[0])
-
-        # Check exclusions
-        config = {
-            "TE01": {"exclusions": {"messages": ["foo"]}},
-            "TE03": {"exclusions": {"messages": ["foo"]}},
-        }
-        results = self.checkContent(config, content)
-        self.assertEqual(len(results), 0)
-
-    def testTE04(self):
-        content = """
-foo = bar "bar" bar
-# This shouldn't trigger an error
-foo1 = { -someterm(capitalization: "uppercase") }
-foo-datetime = Test: { DATETIME($timeChanged, day: "numeric", month: "long", year: "numeric") }
-foo-number = { NUMBER($mem, maxFractionalUnits: 2) } MB
-foo-empty = { "" }
-foo-space = { "" } test
-foo-curly1 = { "{" } test
-foo-curly2 = { "}" } test
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 1)
-        self.assertTrue("TE04" in results[0])
-        self.assertTrue("foo" in results[0])
-
-        # Check exclusions
-        config = {"TE04": {"exclusions": {"messages": ["foo"]}}}
-        results = self.checkContent(config, content)
-        self.assertEqual(len(results), 0)
-
-    def testTE05(self):
-        content = """
-foo = bar...
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 1)
-        self.assertTrue("TE05" in results[0])
-
-        # Check exclusions
-        config = {"TE05": {"exclusions": {"messages": ["foo"]}}}
-        results = self.checkContent(config, content)
-        self.assertEqual(len(results), 0)
-
-        content = """
-foo = bar…
-"""
-        results = self.checkContent({}, content)
-        self.assertEqual(len(results), 0)