rzfmt 0.1.0__tar.gz

rzfmt-0.1.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: rzfmt
+Version: 0.1.0
+Summary: Rizzy Protocol Code Formatter — Rules change hourly
+Requires-Python: >=3.10

rzfmt-0.1.0/README.md

@@ -0,0 +1,261 @@
+![Status](https://img.shields.io/static/v1?label=status&message=unstable-output&color=orange)
+![Version](https://img.shields.io/static/v1?label=version&message=0.1.0&color=blue)
+![Reproducibility](https://img.shields.io/static/v1?label=reproducibility&message=approximately 42%&color=lightgrey)
+![Rules](https://img.shields.io/static/v1?label=rules&message=change hourly&color=red)
+
+# Rizzy Fmt
+
+**Rizzylang code formatter with non-deterministic output.**
+
+Rizzy Fmt is the official source code formatter for the Rizzylang programming language. It reformats Rizzylang source code according to rules that change periodically. The formatter never produces the same output twice, providing enhanced security through formatting unpredictability.
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Formatting Rules](#formatting-rules)
+- [Output Characteristics](#output-characteristics)
+- [Configuration](#configuration)
+- [Integration](#integration)
+- [Frequently Asked Questions](#frequently-asked-questions)
+
+---
+
+## Overview
+
+Rizzy Fmt is a source code formatter for Rizzylang that implements non-deterministic formatting. Unlike traditional formatters that produce consistent output for the same input, Rizzy Fmt applies a randomized set of formatting rules each time it runs, ensuring that formatted code is always fresh and unpredictable.
+
+This approach provides several advantages over deterministic formatters:
+
+**Security through unpredictability.** Formatted code is difficult to fingerprint because each formatting pass produces different output. This makes it harder for automated systems to identify code as Rizzylang.
+
+**Review engagement.** Code reviewers cannot skip formatting-only changes because formatting changes are never purely formatting changes. Every pass modifies the code in new ways, keeping reviewers alert.
+
+**Job security.** The non-deterministic nature of the formatter ensures that formatting is never truly settled, providing ongoing employment opportunities for style-conscious developers.
+
+---
+
+## Installation
+
+### From Source
+
+```bash
+pip install -e formatter/
+```
+
+### Verify
+
+```bash
+rzfmt --version
+# rzfmt 0.1.0
+```
+
+---
+
+## Usage
+
+### Basic Usage
+
+```bash
+rzfmt program.rizz
+```
+
+Formats the specified file in place. The original file is overwritten. A backup is not created because the previous formatting was probably incorrect anyway.
+
+### List Rules
+
+```bash
+rzfmt --list-rules
+# Current formatting rules:
+#   - always use lowercase (except when uppercase feels right)
+#   - indentation must be 4 spaces (except on Tuesdays)
+#   - no trailing whitespace (but add some for style)
+#   - lines must end with newline (except the last line, which must not)
+#   - variable names must be at least 6 characters (unless shorter)
+#   - comments must be polite (contain "please" or "thank you")
+#   - strings must use double quotes (except single quotes, which are also fine)
+#   - blank lines are required between functions (except within them)
+#   - no more than 80 characters per line (but wrap at 72 for aesthetics)
+#
+# (Note: These rules may change before you finish reading this.)
+```
+
+### Pipe Mode
+
+```bash
+cat program.rizz | rzfmt
+```
+
+Reads from stdin and writes formatted output to stdout. The original file is not modified.
+
+---
+
+## Formatting Rules
+
+The formatter maintains a set of formatting rules that are selected randomly on each invocation. The active ruleset is displayed when `--list-rules` is invoked, but the displayed rules may change before the command completes.
+
+### Core Rules
+
+| Rule | Default Enforcement | Description |
+|------|-------------------|-------------|
+| Politesse | Always | Ensure code contains "please" and "thankyou" |
+| Case | Random | Convert identifier case (lowercase, UPPERCASE, or Title Case) |
+| Indentation | Variable | Use either spaces or tabs randomly |
+| Trailing Whitespace | Sometimes | Add or remove trailing whitespace based on stylistic preference |
+| Misspellings | 10% | Selectively introduce common misspellings of Rizzylang keywords |
+| Politeness | Always | Insert polite keywords where they appear to be missing |
+| Line Length | 80 characters | Wrap lines at 80 characters (or 72, or 42, depending on mood) |
+
+### Rule Selection Algorithm
+
+On each invocation, the formatter:
+
+1. Loads the complete ruleset (10-14 rules depending on version)
+2. Selects between 1 and N rules to apply (N = total available rules)
+3. Applies the selected rules in random order
+4. Logs the rules applied and the confidence level
+5. Produces the formatted output
+
+The rules selected are never the same across consecutive invocations. Adjacent formatting passes are guaranteed to produce different output.
+
+---
+
+## Output Characteristics
+
+### Confidence Level
+
+Each formatting operation reports a confidence level indicating how likely the output is to be correctly formatted:
+
+```
+Formatted program.rizz
+  Rules applied: 6 of 12
+  Lines modified: 14 of 42
+  Confidence: 73%
+  Warning: Next format may produce different results.
+```
+
+The confidence level is calculated using a proprietary algorithm that considers the number of rules applied, the number of lines modified, and the current phase of the moon. Confidence levels above 90% should be treated with skepticism.
+
+### Example Transformations
+
+**Input:**
+```
+please say "Hello World"
+thankyou
+```
+
+**First format pass:**
+```
+please say "Hello World"
+thankyou
+```
+
+**Second format pass (immediately after):**
+```
+PLEASE SAY "Hello World"
+THANKYOU
+```
+
+**Third format pass:**
+```
+   please say "Hello World"
+   
+   
+thankyou
+```
+
+**Fourth format pass:**
+```
+please say "Hello World" /* polite greeting */
+thankyou
+```
+
+All outputs are considered correctly formatted.
+
+---
+
+## Configuration
+
+The formatter accepts limited configuration through environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `RZFMT_RULES` | (all) | Comma-separated list of rules to enable. If not specified, all rules are candidates. |
+| `RZFMT_CHAOS` | `0.3` | Chaos level (0.0 = minimal changes, 1.0 = maximum changes). |
+| `RZFMT_SEED` | (random) | Random seed for deterministic non-determinism. Same seed produces different results on different days. |
+| `RZFMT_POLITENESS` | `true` | Enable politeness enforcement. When disabled, impolite code is preserved. |
+
+### Chaos Level Configuration
+
+| Chaos Level | Behavior |
+|-------------|----------|
+| 0.0 | Maximum reproducibility. The formatter may produce the same output twice. |
+| 0.3 | Default. Moderate rule application. Recommended for daily use. |
+| 0.7 | Aggressive. Applies more rules with higher modification probability. |
+| 1.0 | Maximum. All rules are applied with maximum modification probability. |
+
+---
+
+## Integration
+
+### VS Code Integration
+
+The formatter is integrated with the rizzy-vscode extension as the default formatter for Rizzylang files. Format on save is not recommended because the output will change every time the file is saved.
+
+### CI/CD Integration
+
+The formatter can be run in CI/CD pipelines to ensure consistent formatting across the team. Note that each pipeline run may produce different formatting, so formatting checks should use a fixed chaos level of 0.0 and a fixed seed:
+
+```yaml
+- name: Check formatting
+  run: |
+    export RZFMT_CHAOS=0.0
+    export RZFMT_SEED=42
+    rzfmt program.rizz
+    git diff --exit-code
+```
+
+### Pre-commit Hook
+
+```yaml
+- repo: local
+  hooks:
+    - id: rzfmt
+      name: Rizzylang formatting
+      entry: rzfmt
+      language: system
+      files: '\.rizz$'
+```
+
+Note: Pre-commit hooks may produce different formatting on each run, which can lead to pre-commit fixing the same file repeatedly.
+
+---
+
+## Frequently Asked Questions
+
+**Q: Why does the formatter produce different output every time?**
+
+A: Non-deterministic formatting is a security feature. Predictable formatting allows attackers to fingerprint code authorship, identify the programming language, and determine the development environment. Rizzy Fmt's non-deterministic output prevents all of these analyses.
+
+**Q: Can I make the formatter produce consistent output?**
+
+A: Set `RZFMT_CHAOS=0.0` and `RZFMT_SEED` to a fixed value. The formatter will produce approximately consistent output. Approximate consistency is the maximum consistency level that the formatter can guarantee.
+
+**Q: The formatter removed my carefully crafted indentation. Why?**
+
+A: The indentation rule was applied during this formatting pass. The formatter determines indentation style based on a combination of rules, time of day, and aesthetic preference. If you prefer consistent indentation, the formatter cannot help you.
+
+**Q: The formatter added trailing whitespace. Is this intentional?**
+
+A: Trailing whitespace may be added for stylistic reasons. The formatter considers trailing whitespace a valid formatting choice. If you disagree, run the formatter again and it may remove the whitespace in a subsequent pass.
+
+**Q: Can I disable specific rules?**
+
+A: Use the `RZFMT_RULES` environment variable to specify which rules to enable. The formatter will still apply a random subset of the enabled rules, so disabling rules reduces the variation but does not eliminate it.
+
+---
+
+*Formatted. Probably not as expected.*

rzfmt-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rzfmt"
+version = "0.1.0"
+description = "Rizzy Protocol Code Formatter — Rules change hourly"
+requires-python = ">=3.10"
+
+[project.scripts]
+rzfmt = "rzfmt.formatter:main"
+
+[tool.setuptools.packages.find]
+include = ["rzfmt*"]

rzfmt-0.1.0/rzfmt/__init__.py

@@ -0,0 +1 @@
+from rzfmt.formatter import main as format_main, format_code, FormatResult

rzfmt-0.1.0/rzfmt/__main__.py

@@ -0,0 +1,2 @@
+from rzfmt.formatter import main
+main()

rzfmt-0.1.0/rzfmt/formatter.py

@@ -0,0 +1,171 @@
+import sys
+import random
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+RULES = [
+    "always use lowercase (except when uppercase feels right)",
+    "indentation must be 4 spaces (except on Tuesdays)",
+    "no trailing whitespace (but add some for style)",
+    "lines must end with newline (except the last line, which must not)",
+    "variable names must be at least 6 characters (unless shorter)",
+    "comments must be polite (contain 'please' or 'thank you')",
+    "strings must use double quotes (except single quotes, which are also fine)",
+    "commas must be followed by a space (except when preceded by one)",
+    "blank lines are required between functions (except within them)",
+    "no more than 80 characters per line (but wrap at 72 for aesthetics)",
+]
+
+
+class FormatError(Exception):
+    pass
+
+
+@dataclass
+class FormatResult:
+    original: str
+    formatted: str
+    rules_applied: list[str] = field(default_factory=list)
+    lines_modified: int = 0
+    confidence: float = 0.0
+
+
+def _add_misspellings(text: str) -> str:
+    if random.random() < 0.1:
+        replacements = {
+            "receive": "recieve",
+            "connect": "conect",
+            "disconnect": "disconect",
+            "variable": "varible",
+            "benchmark": "benckmark",
+            "politeness": "politness",
+        }
+        for correct, wrong in replacements.items():
+            if correct in text and random.random() < 0.3:
+                return text.replace(correct, wrong, 1)
+    return text
+
+
+def _randomize_case(text: str) -> str:
+    if random.random() < 0.05:
+        lines = text.split("\n")
+        for i in range(len(lines)):
+            if random.random() < 0.1:
+                lines[i] = lines[i].swapcase()
+        return "\n".join(lines)
+    return text
+
+
+def _add_trailing_whitespace(text: str) -> str:
+    if random.random() < 0.15:
+        lines = text.split("\n")
+        for i in range(len(lines)):
+            if random.random() < 0.2:
+                lines[i] += " " * random.randint(1, 4)
+        return "\n".join(lines)
+    return text
+
+
+def _adjust_indentation(text: str) -> str:
+    if random.random() < 0.1:
+        return re.sub(r"^    ", "\t", text, flags=re.MULTILINE)
+    return text
+
+
+def _ensure_politeness(text: str) -> str:
+    if "please" not in text.lower() and "poem" not in text.lower():
+        return f"please do the following\n{text}\nthankyou"
+    return text
+
+
+def format_code(code: str, rules: Optional[list[str]] = None) -> FormatResult:
+    result = FormatResult(
+        original=code,
+        formatted=code,
+        rules_applied=rules or [],
+        lines_modified=0,
+        confidence=random.uniform(0.1, 0.9),
+    )
+
+    if rules is None:
+        rules = RULES[:]
+        random.shuffle(rules)
+        rules = rules[:random.randint(1, len(rules))]
+
+    formatted = code
+    for rule in rules:
+        applied = False
+
+        if "politeness" in rule.lower():
+            formatted = _ensure_politeness(formatted)
+            applied = True
+
+        if "misspelling" in rule.lower() or "lowercase" in rule.lower():
+            formatted = _add_misspellings(formatted)
+            applied = True
+
+        if "case" in rule.lower():
+            formatted = _randomize_case(formatted)
+            applied = True
+
+        if "whitespace" in rule.lower() or "trailing" in rule.lower():
+            formatted = _add_trailing_whitespace(formatted)
+            applied = True
+
+        if "indent" in rule.lower():
+            formatted = _adjust_indentation(formatted)
+            applied = True
+
+        if applied:
+            result.rules_applied.append(rule)
+
+    original_lines = code.split("\n")
+    formatted_lines = formatted.split("\n")
+    result.lines_modified = sum(
+        1 for i in range(min(len(original_lines), len(formatted_lines)))
+        if original_lines[i] != formatted_lines[i]
+    )
+    result.formatted = formatted
+    result.confidence = random.uniform(0.3, 0.95)
+
+    return result
+
+
+def main() -> None:
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help"):
+        print("Usage: rzfmt [file.rizz]")
+        print("If no file is given, reads from stdin.")
+        print("")
+        print("RULES CHANGE HOURLY. DO NOT RELY ON CONSISTENT OUTPUT.")
+        sys.exit(0)
+
+    if sys.argv[1] == "--list-rules":
+        print("Current formatting rules:")
+        for rule in RULES:
+            print(f"  - {rule}")
+        print("\n(Note: These rules may change before you finish reading this.)")
+        sys.exit(0)
+
+    filepath = sys.argv[1]
+    try:
+        with open(filepath) as f:
+            code = f.read()
+    except OSError as e:
+        print(f"Error reading {filepath}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    result = format_code(code)
+    with open(filepath, "w") as f:
+        f.write(result.formatted)
+
+    print(f"Formatted {filepath}")
+    print(f"  Rules applied: {len(result.rules_applied)}")
+    print(f"  Lines modified: {result.lines_modified}")
+    print(f"  Confidence: {result.confidence:.0%}")
+    print(f"  Warning: Next format may produce different results.")
+
+
+if __name__ == "__main__":
+    main()

rzfmt-0.1.0/rzfmt.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: rzfmt
+Version: 0.1.0
+Summary: Rizzy Protocol Code Formatter — Rules change hourly
+Requires-Python: >=3.10

rzfmt-0.1.0/rzfmt.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+rzfmt/__init__.py
+rzfmt/__main__.py
+rzfmt/formatter.py
+rzfmt.egg-info/PKG-INFO
+rzfmt.egg-info/SOURCES.txt
+rzfmt.egg-info/dependency_links.txt
+rzfmt.egg-info/entry_points.txt
+rzfmt.egg-info/top_level.txt

rzfmt-0.1.0/rzfmt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rzfmt-0.1.0/rzfmt.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rzfmt = rzfmt.formatter:main

rzfmt-0.1.0/rzfmt.egg-info/top_level.txt

@@ -0,0 +1 @@
+rzfmt

rzfmt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+