chore(nix): use craneLib.devShell

.gitignore

@@ -1,13 +1,4 @@
-.luarc.json
-target
-
-# Devenv
-.devenv*
-devenv.local.nix
-devenv.local.yaml
-
-# direnv
-.direnv
-
-# pre-commit
-.pre-commit-config.yaml
+/.direnv
+/.luarc.json
+/result*
+/target

default.nix

@@ -1,19 +1,15 @@
 {
-  lib,
+  craneLib,
   pkgs,
-  rust,
-  self,
 }:
-pkgs.rustPlatform.buildRustPackage {
+craneLib.buildPackage {
   pname = "errornowatcher";
-  version = self.shortRev or self.dirtyShortRev;
+  version = "0.2.0";
 
-  cargoLock.lockFile = ./Cargo.lock;
-  src = lib.cleanSource ./.;
+  src = craneLib.cleanCargoSource ./.;
 
   nativeBuildInputs = with pkgs; [
-    rust
-
+    clang
     mold
     pkg-config
   ];

flake.lock

@@ -1,15 +1,51 @@
 {
   "nodes": {
+    "crane": {
+      "locked": {
+        "lastModified": 1778106249,
+        "narHash": "sha256-cM/AuKy5tMhwOOQIbha8ZRRMHVfNf7cv2aljIw+qoCg=",
+        "owner": "ipetkov",
+        "repo": "crane",
+        "rev": "6d015ea29630b7ad2402841386da2cb617a470a7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "ipetkov",
+        "repo": "crane",
+        "type": "github"
+      }
+    },
+    "fenix": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "rust-analyzer-src": "rust-analyzer-src"
+      },
+      "locked": {
+        "lastModified": 1778314245,
+        "narHash": "sha256-a8p3JMunVzj0o86V9CNTyEFw7z4105QWl+bEz6Du8Jw=",
+        "owner": "nix-community",
+        "repo": "fenix",
+        "rev": "f54d645218048a7abe226983a922cdaca63cd845",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "fenix",
+        "type": "github"
+      }
+    },
     "flake-parts": {
       "inputs": {
         "nixpkgs-lib": "nixpkgs-lib"
       },
       "locked": {
-        "lastModified": 1777678872,
-        "narHash": "sha256-EPIFsulyon7Z1vLQq5Fk64GR8L7cQsT+IPhcsukVbgk=",
+        "lastModified": 1777988971,
+        "narHash": "sha256-qIoWPDs+0/8JecyYgE3gpKQxW/4bLW/gp45vow9ioCQ=",
         "owner": "hercules-ci",
         "repo": "flake-parts",
-        "rev": "5250617bffd85403b14dbf43c3870e7f255d2c16",
+        "rev": "0678d8986be1661af6bb555f3489f2fdfc31f6ff",
         "type": "github"
       },
       "original": {
@@ -20,11 +56,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1777268161,
-        "narHash": "sha256-bxrdOn8SCOv8tN4JbTF/TXq7kjo9ag4M+C8yzzIRYbE=",
+        "lastModified": 1777954456,
+        "narHash": "sha256-hGdgeU2Nk87RAuZyYjyDjFL6LK7dAZN5RE9+hrDTkDU=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1c3fe55ad329cbcb28471bb30f05c9827f724c76",
+        "rev": "549bd84d6279f9852cae6225e372cc67fb91a4c1",
         "type": "github"
       },
       "original": {
@@ -51,28 +87,26 @@
     },
     "root": {
       "inputs": {
+        "crane": "crane",
+        "fenix": "fenix",
         "flake-parts": "flake-parts",
-        "nixpkgs": "nixpkgs",
-        "rust-overlay": "rust-overlay"
+        "nixpkgs": "nixpkgs"
       }
     },
-    "rust-overlay": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
+    "rust-analyzer-src": {
+      "flake": false,
       "locked": {
-        "lastModified": 1777605393,
-        "narHash": "sha256-Hjp0VOOHgHcTrX23iVvnfAudPcuCmfkfpQNFwv2v/ks=",
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "rev": "ff88db34cfa486fc4964a6991cab1678d82eee8c",
+        "lastModified": 1778246258,
+        "narHash": "sha256-RUZuOfzouSaK/VjcOCU/P5Nb3EhpM8qGnIcHWIIo4Sw=",
+        "owner": "rust-lang",
+        "repo": "rust-analyzer",
+        "rev": "73ca1d4ef136e2367627d698f00db94882b49440",
         "type": "github"
       },
       "original": {
-        "owner": "oxalica",
-        "repo": "rust-overlay",
+        "owner": "rust-lang",
+        "ref": "nightly",
+        "repo": "rust-analyzer",
         "type": "github"
       }
     }

flake.nix

@@ -1,21 +1,22 @@
 {
   inputs = {
+    crane.url = "github:ipetkov/crane";
+
+    fenix = {
+      url = "github:nix-community/fenix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
     flake-parts.url = "github:hercules-ci/flake-parts";
 
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-
-    rust-overlay = {
-      url = "github:oxalica/rust-overlay";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
   };
 
   outputs =
     {
+      crane,
+      fenix,
       flake-parts,
-      nixpkgs,
-      rust-overlay,
-      self,
       ...
     }@inputs:
     flake-parts.lib.mkFlake { inherit inputs; } {
@@ -32,32 +33,23 @@
           ...
         }:
         let
-          rust = pkgs.rust-bin.nightly.latest.default.override {
-            extensions = [
-              "rust-src"
-              "rust-analyzer-preview"
-            ];
-          };
+          craneLib = (crane.mkLib pkgs).overrideToolchain fenix.packages.${system}.complete.toolchain;
         in
         {
-          _module.args.pkgs = import nixpkgs {
-            inherit system;
-            overlays = [ rust-overlay.overlays.default ];
-          };
-
-          devShells.default = pkgs.mkShell {
+          devShells.default = craneLib.devShell {
             name = "errornowatcher";
 
             inputsFrom = [ self'.packages.default ];
             nativeBuildInputs = [ pkgs.pkg-config ];
             buildInputs = [ pkgs.taplo ];
 
+            PKG_CONFIG_PATH = "${pkgs.openssl.dev}/lib/pkgconfig";
             RUST_BACKTRACE = 1;
           };
 
           packages = rec {
             default = errornowatcher;
-            errornowatcher = pkgs.callPackage ./. { inherit rust self; };
+            errornowatcher = pkgs.callPackage ./. { inherit craneLib; };
           };
         };
     };

lib/automation.lua

@@ -99,7 +99,7 @@ function attack_entities(target_kind, minimum)
 			pos.y = pos.y + 1.5
 
 			hold_sword()
-			client:look_at(pos)
+			client.looking_at = pos
 			client:attack(e.id)
 			while client.has_attack_cooldown do
 				sleep(100)

lib/inventory.lua

@@ -6,7 +6,7 @@ function hold_items_in_hotbar(target_kinds, inventory)
 		if index >= 37 and index <= 45 and table.contains(target_kinds, item.kind) then
 			inventory = nil
 			sleep(500)
-			client:set_held_slot(index - 37)
+			client.held_slot = index - 37
 			return true
 		end
 	end
@@ -35,7 +35,7 @@ end
 function steal(item_name)
 	for _, chest_pos in ipairs(client:find_blocks(client.position, get_block_states({ "chest" }))) do
 		client:go_to({ position = chest_pos, radius = 3 }, { type = RADIUS_GOAL })
-		client:look_at(chest_pos)
+		client.looking_at = chest_pos
 
 		local container = client:open_container_at(chest_pos)
 		for index, item in ipairs(container.contents) do

lib/movement.lua

@@ -2,7 +2,7 @@ function look_at_player(name)
 	local player = get_player(name)
 	if player then
 		player.position.y = player.position.y + 1
-		client:look_at(player.position)
+		client.looking_at = player.position
 	end
 end
 

lib/utils.lua

@@ -141,7 +141,7 @@ function interact_bed()
 	end
 
 	client:go_to({ position = bed, radius = 2 }, { type = RADIUS_GOAL, options = { without_mining = true } })
-	client:look_at(bed)
+	client.looking_at = bed
 	client:block_interact(bed)
 end
 

src/lua/client/container.rs

@@ -17,7 +17,7 @@ pub fn held_item(_lua: &Lua, client: &Client) -> Result<ItemStack> {
     Ok(ItemStack(client.get_held_item()))
 }
 
-pub fn held_slot(_lua: &Lua, client: &Client) -> Result<u8> {
+pub fn get_held_slot(_lua: &Lua, client: &Client) -> Result<u8> {
     Ok(client.component::<Inventory>().selected_hotbar_slot)
 }
 
@@ -113,7 +113,7 @@ pub fn open_inventory(_lua: &Lua, client: &Client, (): ()) -> Result<Option<Cont
     Ok(client.open_inventory().map(Container))
 }
 
-pub fn set_held_slot(_lua: &Lua, client: &Client, slot: u8) -> Result<()> {
+pub fn set_held_slot(_lua: &Lua, client: &mut Client, slot: u8) -> Result<()> {
     if slot > 8 {
         return Ok(());
     }

src/lua/client/interaction.rs

@@ -43,7 +43,11 @@ pub async fn mine(_lua: Lua, client: UserDataRef<Client>, position: Vec3) -> Res
     Ok(())
 }
 
-pub fn set_mining(_lua: &Lua, client: &Client, state: bool) -> Result<()> {
+pub fn get_mining(_lua: &Lua, client: &Client) -> Result<bool> {
+    Ok(client.is_mining())
+}
+
+pub fn set_mining(_lua: &Lua, client: &mut Client, state: bool) -> Result<()> {
     client.left_click_mine(state);
     Ok(())
 }

src/lua/client/mod.rs

@@ -33,20 +33,30 @@ impl UserData for Client {
         f.add_field_method_get("air_supply", state::air_supply);
         f.add_field_method_get("container", container::container);
         f.add_field_method_get("dimension", world::dimension);
-        f.add_field_method_get("direction", movement::direction);
+        f.add_field_method_get("direction", movement::get_direction);
+        f.add_field_method_set("direction", movement::set_direction);
         f.add_field_method_get("experience", state::experience);
         f.add_field_method_get("eye_position", movement::eye_position);
         f.add_field_method_get("go_to_reached", movement::go_to_reached);
         f.add_field_method_get("has_attack_cooldown", interaction::has_attack_cooldown);
         f.add_field_method_get("health", state::health);
         f.add_field_method_get("held_item", container::held_item);
-        f.add_field_method_get("held_slot", container::held_slot);
+        f.add_field_method_get("held_slot", container::get_held_slot);
+        f.add_field_method_set("held_slot", container::set_held_slot);
         f.add_field_method_get("hunger", state::hunger);
         f.add_field_method_get("id", id);
-        f.add_field_method_get("looking_at", movement::looking_at);
+        f.add_field_method_get("jumping", movement::get_jumping);
+        f.add_field_method_set("jumping", movement::set_jumping);
+        f.add_field_method_get("looking_at", movement::get_looking_at);
+        f.add_field_method_set("looking_at", movement::set_looking_at);
         f.add_field_method_get("menu", container::menu);
+        f.add_field_method_get("mining", interaction::get_mining);
+        f.add_field_method_set("mining", interaction::set_mining);
         f.add_field_method_get("pathfinder", movement::pathfinder);
-        f.add_field_method_get("position", movement::position);
+        f.add_field_method_get("position", movement::get_position);
+        f.add_field_method_set("position", movement::set_position);
+        f.add_field_method_get("sneaking", movement::get_sneaking);
+        f.add_field_method_set("sneaking", movement::set_sneaking);
         f.add_field_method_get("tab_list", tab_list);
         f.add_field_method_get("username", username);
         f.add_field_method_get("uuid", uuid);
@@ -72,15 +82,8 @@ impl UserData for Client {
         m.add_method("get_block_state", world::get_block_state);
         m.add_method("get_fluid_state", world::get_fluid_state);
         m.add_method("jump", movement::jump);
-        m.add_method("look_at", movement::look_at);
         m.add_method("open_inventory", container::open_inventory);
         m.add_method("set_component", state::set_component);
-        m.add_method("set_direction", movement::set_direction);
-        m.add_method("set_held_slot", container::set_held_slot);
-        m.add_method("set_jumping", movement::set_jumping);
-        m.add_method("set_mining", interaction::set_mining);
-        m.add_method("set_position", movement::set_position);
-        m.add_method("set_sneaking", movement::set_sneaking);
         m.add_method("sprint", movement::sprint);
         m.add_method("start_mining", interaction::start_mining);
         m.add_method("start_use_item", interaction::start_use_item);

src/lua/client/movement.rs

@@ -125,7 +125,7 @@ pub async fn start_go_to(
     Ok(())
 }
 
-pub fn direction(_lua: &Lua, client: &Client) -> Result<Direction> {
+pub fn get_direction(_lua: &Lua, client: &Client) -> Result<Direction> {
     let direction = client.direction();
     Ok(Direction {
         y: direction.y_rot(),
@@ -133,6 +133,11 @@ pub fn direction(_lua: &Lua, client: &Client) -> Result<Direction> {
     })
 }
 
+pub fn set_direction(_lua: &Lua, client: &mut Client, direction: Direction) -> Result<()> {
+    client.set_direction(direction.y, direction.x);
+    Ok(())
+}
+
 pub fn eye_position(_lua: &Lua, client: &Client) -> Result<Vec3> {
     Ok(Vec3::from(client.eye_position()))
 }
@@ -142,7 +147,7 @@ pub fn jump(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
     Ok(())
 }
 
-pub fn looking_at(lua: &Lua, client: &Client) -> Result<Option<Table>> {
+pub fn get_looking_at(lua: &Lua, client: &Client) -> Result<Option<Table>> {
     Ok(
         if let HitResult::Block(ref result) = **client.component::<HitResultComponent>() {
             let table = lua.create_table()?;
@@ -158,7 +163,7 @@ pub fn looking_at(lua: &Lua, client: &Client) -> Result<Option<Table>> {
     )
 }
 
-pub fn look_at(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
+pub fn set_looking_at(_lua: &Lua, client: &mut Client, position: Vec3) -> Result<()> {
     client.look_at(azalea::Vec3::new(position.x, position.y, position.z));
     Ok(())
 }
@@ -189,21 +194,20 @@ pub fn pathfinder(lua: &Lua, client: &Client) -> Result<Table> {
     Ok(table)
 }
 
-pub fn position(_lua: &Lua, client: &Client) -> Result<Vec3> {
+pub fn get_position(_lua: &Lua, client: &Client) -> Result<Vec3> {
     Ok(Vec3::from(*client.component::<Position>()))
 }
 
-pub fn set_direction(_lua: &Lua, client: &Client, direction: Direction) -> Result<()> {
-    client.set_direction(direction.y, direction.x);
-    Ok(())
+pub fn get_jumping(_lua: &Lua, client: &Client) -> Result<bool> {
+    Ok(client.jumping())
 }
 
-pub fn set_jumping(_lua: &Lua, client: &Client, jumping: bool) -> Result<()> {
+pub fn set_jumping(_lua: &Lua, client: &mut Client, jumping: bool) -> Result<()> {
     client.set_jumping(jumping);
     Ok(())
 }
 
-pub fn set_position(_lua: &Lua, client: &Client, new_pos: Vec3) -> Result<()> {
+pub fn set_position(_lua: &Lua, client: &mut Client, new_pos: Vec3) -> Result<()> {
     client.query_self::<&mut Position, _>(|mut pos| {
         pos.x = new_pos.x;
         pos.y = new_pos.y;
@@ -212,7 +216,11 @@ pub fn set_position(_lua: &Lua, client: &Client, new_pos: Vec3) -> Result<()> {
     Ok(())
 }
 
-pub fn set_sneaking(_lua: &Lua, client: &Client, sneaking: bool) -> Result<()> {
+pub fn get_sneaking(_lua: &Lua, client: &Client) -> Result<bool> {
+    Ok(client.crouching())
+}
+
+pub fn set_sneaking(_lua: &Lua, client: &mut Client, sneaking: bool) -> Result<()> {
     client.set_crouching(sneaking);
     Ok(())
 }