chore: rename 'Rung' -> 'rung' cause it's less distracting

Author: ssweber

docs/blog/complexity-was-never-in-the-logic.md

@@ -10,20 +10,20 @@ I wrote [ClickNick](https://github.com/ssweber/clicknick) to help with the addre
 
 The logic itself was never complex. Each subroutine is basically a one-page function. But the editor makes it feel enormous. You can't see more than a few rungs at a time, search and replace exist but they're clunky, there's no diff, no way to look at the whole program at once. The bottleneck was always the editor. This [isn't unique to Click](https://blog.jonasneubert.com/2019/10/29/ladder-logic/), either.
 
-I wanted one source of truth. So I turned the cheatsheet into [pyrung](https://ssweber.github.io/pyrung/), a Python library where `with Rung(Start): latch(Motor)` maps directly to a ladder rung. The scan cycle runs for real, timers accumulate, rung order matters. You test with pytest, step through scans in VS Code.
+I wanted one source of truth. So I turned the cheatsheet into [pyrung](https://ssweber.github.io/pyrung/), a Python library where `with rung(Start): latch(Motor)` maps directly to a ladder rung. The scan cycle runs for real, timers accumulate, rung order matters. You test with pytest, step through scans in VS Code.
 
 Three rungs that copy a command value based on a state. In pyrung, that's six lines:
 
 ```python
-with Rung(Cmd_State_Reset):
+with rung(Cmd_State_Reset):
     copy(1, Cmd_CtrlCmd)
     copy(1, Cmd_CmdChgRequestBool)
 
-with Rung(Cmd_State_Start):
+with rung(Cmd_State_Start):
     copy(2, Cmd_CtrlCmd)
     copy(1, Cmd_CmdChgRequestBool)
 
-with Rung(Cmd_State_Stop):
+with rung(Cmd_State_Stop):
     copy(3, Cmd_CtrlCmd)
     copy(1, Cmd_CmdChgRequestBool)
 ```

docs/blog/these-arent-the-rungs.md

@@ -2,7 +2,7 @@
 
 ### How I reverse-engineered a PLC editor's clipboard format so my bytes could paste without any problems
 
-Ladder logic is the visual programming language for industrial controllers, rungs on a rail, each one a circuit that evaluates left to right: `|—[ Contact ]—( Output )|`. For years I haven't been able to test my CLICK PLC programs. I've got dozens of machines whose logic is stuck in an editor with no simulator, no scripting API, and no documented file format. So I built [pyrung](https://ssweber.github.io/pyrung/), a Python DSL where `with Rung(condition): instruction` maps directly to a ladder rung, meaning you can write logic in Python and test it with pytest.
+Ladder logic is the visual programming language for industrial controllers, rungs on a rail, each one a circuit that evaluates left to right: `|—[ Contact ]—( Output )|`. For years I haven't been able to test my CLICK PLC programs. I've got dozens of machines whose logic is stuck in an editor with no simulator, no scripting API, and no documented file format. So I built [pyrung](https://ssweber.github.io/pyrung/), a Python DSL where `with rung(condition): instruction` maps directly to a ladder rung, meaning you can write logic in Python and test it with pytest.
 
 But I don't want to transpose after testing. The missing piece was getting rungs from Python into the CLICK editor without retyping them. There's no documented import format, but I found it does put ctrl-c rungs onto the clipboard in some binary format. Maybe I could figure it out. With an AI that could hold context across hex dumps and structural hypotheses, I decided to give it a go.
 

docs/blog/why-pyrung.md

@@ -40,7 +40,7 @@ SOR BST GRT Temp 100 NXB GRT Pressure 50 BND OTE Alarm EOR
 
 **pyladdersim** (flat list):
 ```python
-rung = Rung([Contact("Start"), InvertedContact("Stop"), Output("Lamp")])
+rung = rung([Contact("Start"), InvertedContact("Stop"), Output("Lamp")])
 ```
 
 The structure that makes ladder readable is lost in all of these. The idea of a proper text-based ladder with testability has been [floating around since at least 2000](https://mail.python.org/pipermail/python-list/2000-March/049350.html), but nobody shipped it. A CODESYS Forge user [asked for ladder scripting in Python in 2017](https://forge.codesys.com/forge/talk/Engineering/thread/fdc3d03c95/); the answer was "You can't do Ladder with Scripting."
@@ -50,10 +50,10 @@ The structure that makes ladder readable is lost in all of these. The idea of a
 The same two examples:
 
 ```python
-with Rung(Start | Motor, ~Stop):
+with rung(Start | Motor, ~Stop):
     out(Motor)
 
-with Rung(any_of(Temp > 100, Pressure > 50)):
+with rung(any_of(Temp > 100, Pressure > 50)):
     latch(Alarm)
 ```
 

docs/index.md

@@ -90,10 +90,10 @@
 <div class="pl-block">
 <div><span class="pl-kw">with</span> <span class="pl-cls">Program</span>() <span class="pl-kw">as</span> logic:</div>
 <div class="pl-blank"></div>
-<div id="r1c">    <span class="pl-kw">with</span> <span class="pl-cls">Rung</span>(Start<span class="pl-op">,</span> <span class="pl-op">~</span>Stop):<span class="pl-anno" id="a1c">True</span></div>
+<div id="r1c">    <span class="pl-kw">with</span> <span class="pl-cls">rung</span>(Start<span class="pl-op">,</span> <span class="pl-op">~</span>Stop):<span class="pl-anno" id="a1c">True</span></div>
 <div id="r1b">        <span class="pl-fn">latch</span>(Motor)<span class="pl-anno" id="a1b">Motor ← True</span></div>
 <div class="pl-blank"></div>
-<div id="r2c">    <span class="pl-kw">with</span> <span class="pl-cls">Rung</span>(Stop):<span class="pl-anno" id="a2c">False</span></div>
+<div id="r2c">    <span class="pl-kw">with</span> <span class="pl-cls">rung</span>(Stop):<span class="pl-anno" id="a2c">False</span></div>
 <div id="r2b">        <span class="pl-fn">reset</span>(Motor)<span class="pl-anno" id="a2b">skipped</span></div>
 </div>
 
@@ -150,7 +150,7 @@
 })();
 </script>
 
-That's ladder logic. Condition on the `Rung`, instruction in the body. It reads like the diagram, runs as a deterministic scan cycle, tests with pytest, and compiles to real hardware.
+That's ladder logic. Condition on the `rung`, instruction in the body. It reads like the diagram, runs as a deterministic scan cycle, tests with pytest, and compiles to real hardware.
 
 Ladder logic dominates North American discrete manufacturing, but the tooling hasn't kept up. No version control, no automated testing, no way to simulate without hardware. The Structured Text crowd has options. The ladder crowd doesn't.