jarify 0.3.2__tar.gz → 0.4.0__tar.gz

{jarify-0.3.2 → jarify-0.4.0}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.4.0] - 2026-04-27
+### Features
+
+- add prefer-neq-operator rule — rewrite <> to != ([#206](https://github.com/amfaro/jarify/pull/206)) ([#206](https://github.com/amfaro/jarify/pull/206))
+
+## [0.3.3] - 2026-04-27
+### Bug Fixes
+
+- place trailing rust fmt placeholder before statement terminator ([#201](https://github.com/amfaro/jarify/pull/201)) ([#201](https://github.com/amfaro/jarify/pull/201))
+
 ## [0.3.2] - 2026-04-27
 ### Bug Fixes
 

{jarify-0.3.2 → jarify-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarify
-Version: 0.3.2
+Version: 0.4.0
 Summary: Bespoke SQL linter and formatter for DuckDB, powered by sqlglot
 Project-URL: Homepage, https://github.com/amfaro/jarify
 Project-URL: Repository, https://github.com/amfaro/jarify

{jarify-0.3.2 → jarify-0.4.0}/docs/sql-style-guide.md

@@ -986,3 +986,27 @@ SELECT
 FROM _base
 ;
 ```
+
+---
+
+### `prefer-neq-operator`
+
+Always use `!=` for inequality comparisons instead of the SQL-92 `<>` operator.
+Both are valid in DuckDB, but `!=` is the modern standard.
+The formatter rewrites `<>` to `!=` automatically.
+
+**Bad**
+```sql
+SELECT a
+FROM t
+WHERE x <> y
+```
+
+**Good**
+```sql
+SELECT
+   a
+FROM t
+WHERE x != y
+;
+```

{jarify-0.3.2 → jarify-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jarify"
-version = "0.3.2"
+version = "0.4.0"
 description = "Bespoke SQL linter and formatter for DuckDB, powered by sqlglot"
 readme = "README.md"
 requires-python = ">=3.12"

{jarify-0.3.2 → jarify-0.4.0}/src/jarify/config.py

@@ -45,6 +45,7 @@ class JarifyConfig:
     prefer_using_over_on: str = "warn"  # suggest USING (col) over ON a.col = b.col
     consistent_empty_array: str = "warn"  # prefer [] over '[]'::type[] empty array
     no_select_star_in_cte: str = "warn"  # flag SELECT * inside CTE bodies
+    prefer_neq_operator: str = "warn"  # rewrite <> to != inequality operator
 
     # --- per-rule overrides (populated from [rules.*] in toml) ---
     rules: dict[str, Any] = field(default_factory=dict)

{jarify-0.3.2 → jarify-0.4.0}/src/jarify/formatter.py

@@ -88,11 +88,20 @@ def format_sql(
         tree = _apply_rules(tree, rules)
         formatted_parts.append(generator.generate(tree))
 
-    formatted = "\n;\n\n".join(formatted_parts) + ("\n;\n" if formatted_parts else "")
+    # Join statements but hold off on the trailing ;\n -- it must come *after*
+    # no-anchor line placeholders are re-inserted, otherwise a trailing
+    # {placeholder} ends up after the semicolon instead of before it, which
+    # breaks SQL templates that use the placeholder as an optional WHERE clause.
+    # A trailing \n is appended to ensure the last line ends with a newline so
+    # that no-anchor placeholder re-insertion does not concatenate directly onto
+    # the last SQL token without a line break.
+    formatted = "\n;\n\n".join(formatted_parts) + ("\n" if formatted_parts else "")
     formatted = _unmask_rust_fmt_placeholders(formatted, inline_mask)
     formatted = _unmask_ifnull(formatted)
     formatted = _unmask_numeric(formatted)
     result = _reinsert_line_rust_fmt_placeholders(formatted, line_insertions)
+    if formatted_parts:
+        result = result.rstrip() + "\n;\n"
     return _restore_ctas_body_placeholders(result, ctas_body_map), warnings
 
 

{jarify-0.3.2 → jarify-0.4.0}/src/jarify/generator.py

@@ -862,6 +862,12 @@ class JarifyGenerator(DuckDB.Generator):
         return super().star_sql(expression)
 
     # ------------------------------------------------------------------
+    # Inequality operator: always emit != (never <>)
+    # ------------------------------------------------------------------
+
+    def neq_sql(self, expression: exp.NEQ) -> str:
+        return self.binary(expression, "!=")
+
     # IS NOT NULL: preserve original form instead of NOT x IS NULL
     # ------------------------------------------------------------------
 

{jarify-0.3.2 → jarify-0.4.0}/src/jarify/rules/__init__.py

@@ -15,6 +15,7 @@ from jarify.rules.no_select_star import NoSelectStarRule
 from jarify.rules.no_select_star_in_cte import NoSelectStarInCteRule
 from jarify.rules.no_unused_cte import NoUnusedCteRule
 from jarify.rules.prefer_group_by_all import PreferGroupByAllRule
+from jarify.rules.prefer_neq_operator import PreferNeqOperatorRule
 from jarify.rules.prefer_using_over_on import PreferUsingOverOnRule
 from jarify.rules.trailing_commas import TrailingCommasRule
 
@@ -58,5 +59,7 @@ def get_default_rules(config: JarifyConfig) -> list[FormatterRule]:
         rules.append(ConsistentEmptyArrayRule(severity=config.consistent_empty_array))
     if config.no_select_star_in_cte != "off":
         rules.append(NoSelectStarInCteRule(severity=config.no_select_star_in_cte))
+    if config.prefer_neq_operator != "off":
+        rules.append(PreferNeqOperatorRule(severity=config.prefer_neq_operator))
 
     return rules

jarify-0.4.0/src/jarify/rules/prefer_neq_operator.py

@@ -0,0 +1,53 @@
+"""Rule: rewrite <> to != in inequality expressions."""
+
+from __future__ import annotations
+
+import sqlglot.expressions as exp
+
+from jarify.rules.base import FormatterRule, _node_pos
+from jarify.types import LintViolation
+
+
+class PreferNeqOperatorRule(FormatterRule):
+    """Prefer != over <> for inequality comparisons.
+
+    Both operators are equivalent in DuckDB, but != is the modern standard.
+
+    **Format**: The JarifyGenerator's ``neq_sql`` override always emits ``!=``,
+    so ``apply()`` is a no-op here — the rewrite happens at generation time.
+
+    **Lint**: Because sqlglot normalises both ``!=`` and ``<>`` to the same
+    ``exp.NEQ`` AST node, the lint check cannot distinguish the two from the
+    AST alone.  The check flags every ``NEQ`` node so that users running
+    ``jarify lint`` without first formatting are told to prefer ``!=``.
+    False positives (SQL already using ``!=``) are harmless: running
+    ``jarify fmt`` confirms the canonical form and silences the flag.
+    """
+
+    def __init__(self, severity: str = "warn") -> None:
+        self.severity = severity
+
+    @property
+    def name(self) -> str:
+        return "prefer-neq-operator"
+
+    def apply(self, tree: exp.Expression) -> exp.Expression:
+        # The JarifyGenerator.neq_sql override handles the rewrite to `!=`.
+        return tree
+
+    def check(self, tree: exp.Expression) -> list[LintViolation]:
+        if self.severity == "off":
+            return []
+        violations: list[LintViolation] = []
+        for node in tree.find_all(exp.NEQ):
+            _line, _col = _node_pos(node)
+            violations.append(
+                LintViolation(
+                    rule=self.name,
+                    severity=self.severity,
+                    message="Prefer != over <> for inequality comparisons",
+                    line=_line,
+                    column=_col,
+                )
+            )
+        return violations

jarify-0.4.0/tests/fixtures/operators/prefer_neq_operator.expected.sql

@@ -0,0 +1,7 @@
+SELECT
+   a
+  ,b
+FROM t
+WHERE x != y
+  AND p != q
+;

jarify-0.4.0/tests/fixtures/operators/prefer_neq_operator.input.sql

@@ -0,0 +1,6 @@
+SELECT
+  a
+  , b
+FROM t
+WHERE x <> y
+  AND p <> q

jarify-0.4.0/tests/fixtures/templates/rust_fmt_trailing_placeholder.expected.sql

@@ -0,0 +1,7 @@
+SELECT
+   request_id
+  ,invoice_date
+  ,sku_key
+FROM transactions
+{filter}
+;

jarify-0.4.0/tests/fixtures/templates/rust_fmt_trailing_placeholder.input.sql

@@ -0,0 +1,6 @@
+SELECT
+   request_id
+  ,invoice_date
+  ,sku_key
+FROM transactions
+{filter}

{jarify-0.3.2 → jarify-0.4.0}/tests/test_formatter.py

@@ -225,3 +225,27 @@ class TestGroupByPerLine:
         out, _ = format_sql("SELECT a, count(*) FROM t GROUP BY a")
         assert "GROUP BY" in out
         assert "a" in out
+
+
+class TestTrailingRustFmtPlaceholder:
+    """Trailing whole-line Rust format placeholders must land *before* the
+    statement-terminating semicolon, not after it.
+
+    Regression for: formatter inserts ';' between the last SQL clause and a
+    trailing {placeholder}, producing invalid SQL when Rust substitutes a
+    non-empty value (e.g. 'WHERE seller_key = ...').
+    """
+
+    def test_placeholder_before_semicolon(self):
+        sql = "SELECT a, b\nFROM t\n{filter}"
+        out, _ = format_sql(sql)
+        lines = out.splitlines()
+        filter_idx = next(i for i, line in enumerate(lines) if "{filter}" in line)
+        semi_idx = next(i for i, line in enumerate(lines) if line.strip() == ";")
+        assert filter_idx < semi_idx, f"{{filter}} (line {filter_idx}) must appear before ';' (line {semi_idx}):\n{out}"
+
+    def test_idempotent(self):
+        sql = "SELECT a, b\nFROM t\n{filter}"
+        out, _ = format_sql(sql)
+        out2, _ = format_sql(out)
+        assert out == out2, f"Formatting is not idempotent:\nFirst pass:\n{out}\nSecond pass:\n{out2}"

{jarify-0.3.2 → jarify-0.4.0}/tests/test_lint_rules.py

@@ -308,6 +308,23 @@ class TestViolationPositions:
         assert v.line is not None, "line should not be None"
 
 
+class TestPreferNeqOperator:
+    def test_warns_on_diamond_operator(self):
+        sql = "SELECT a FROM t WHERE x <> y"
+        rules = _lint(sql)
+        assert "prefer-neq-operator" in rules
+
+    def test_warns_on_multiple_neq_expressions(self):
+        sql = "SELECT a FROM t WHERE x <> y AND p <> q"
+        rules = _lint(sql)
+        assert rules.count("prefer-neq-operator") == 2
+
+    def test_off_disables_rule(self):
+        sql = "SELECT a FROM t WHERE x <> y"
+        rules = _lint(sql, prefer_neq_operator="off")
+        assert "prefer-neq-operator" not in rules
+
+
 class TestRustFormatSyntax:
     """SQL files used as Rust format-string templates must not emit parse errors."""
 

{jarify-0.3.2 → jarify-0.4.0}/uv.lock

@@ -34,7 +34,7 @@ wheels = [
 
 [[package]]
 name = "jarify"
-version = "0.3.2"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },