Si vous êtes un geek et que vous utilisez des Mac depuis un certain temps, vous vous souvenez peut-être d’Applescript. C’était un langage développé par Apple pour permettre aux utilisateurs intermédiaires à avancés d’écrire des scripts simples pour contrôler les applications Mac. Il a été conçu pour ressembler à l’anglais, donc accéder à un pixel s’écrivait comme ceci :

pixel 7 of row 3 of TIFF image "my bitmap"

ou même

TIFF image "my bitmap"'s 3rd row's 7th pixel

Inutile de dire qu’il y a une bonne raison pour laquelle les langages de programmation modernes ne ressemblent pas à cela : cela ne passe pas à l’échelle. Quiconque a travaillé avec Applescript pendant de longues périodes sait à quelle vitesse on atteint ses limites. Apple l’a officieusement déprécié en 2016, lorsque Sal Soghoian, son créateur, a été licencié pour des “raisons commerciales”.

Alors qu’Applescript déclinait, un homme sage nommé Steven écrivait Hammerspoon, un pont Lua vers l’API macOS. Lua, en tant que langage de programmation simple et moderne, était un choix parfait. Voyons donc comment l’utiliser.

Installation de Hammerspoon

Utilisez Homebrew.

brew install hammerspoon

Configuration

Créez un fichier appelé ~/.hammerspoon/init.lua.

mkdir ~/.hammerspoon && touch ~/.hammerspoon/init.lua

Ouvrez l’application.

open -a Hammerspoon

Vous devriez voir une console Lua comme celle-ci (ne vous inquiétez pas du texte à l’intérieur).

Cliquez sur Préférences et assurez-vous que l’accessibilité est activée.

Si vous le souhaitez, vous pouvez également cocher Lancer Hammerspoon à la connexion.

Vérifier que init.lua fonctionne

Collez ce qui suit dans le fichier init.lua que vous avez créé.

local logger = hs.logger.new("init.lua", "debug")
logger.d("SUCCESSFULLY RAN init.lua")

Enregistrez le fichier et appuyez sur le bouton Reload dans la console. Si vous voyez la sortie, vous êtes prêt.

Liaison de raccourcis clavier système

La principale chose pour laquelle j’utilise Hammerspoon est de créer des raccourcis “intelligents”, sans avoir à toucher aux raccourcis bogués dans les Préférences ou à télécharger une autre application comme Karabiner. Voici quelques fonctions de base que vous pouvez mettre dans init.lua pour rendre la création de nouveaux raccourcis extrêmement simple.

local function stringsplit(inputstr, sep)
	if sep == nil then
		sep = "%s"
	end
	local t = {}
	for str in string.gmatch(inputstr, "([^" .. sep .. "]+)") do
		table.insert(t, str)
	end
	return t
end

local function keyMapArray(global_modifiers, mappings)
	for k, v in pairs(mappings) do
		if type(v) == "string" then
			-- Les modificateurs que nous mappons
			local modifiers = {}
			local splitkey = stringsplit(v, "-")

			local splitlen = #splitkey
			-- Ajoutez tous les modificateurs mappés contenus dans v
			-- au tableau des modificateurs
			for i = 1, splitlen - 1 do
				modifiers[i] = splitkey[i]
			end

			-- Cela obtient le code de touche à passer à la fonction de liaison
			local mappedKeyCode = hs.keycodes.map[splitkey[splitlen]]
			if mappedKeyCode then
				hs.hotkey.bind(global_modifiers, k, function()
					hs.eventtap.keyStroke(modifiers, mappedKeyCode, 1)
				end)
			else
				-- Le code de touche était nul, ce qui signifie qu'il n'existe pas
				-- Maintenant, nous essayons de le traiter comme un code d'événement système tel que
				-- PLAY
				hs.hotkey.bind(global_modifiers, k, function()
					hs.eventtap.event.newSystemKeyEvent(v, true):post()
					hs.eventtap.event.newSystemKeyEvent(v, false):post()
				end)
			end
		elseif type(v) == "function" then
			hs.hotkey.bind(global_modifiers, k, v)
		end
	end
end

local function processMaps(maps)
	for globals, mappings in pairs(maps) do
		keyMapArray(globals, mappings)
	end
end

Si vous n’êtes pas familier avec Lua et que vous vous sentez intimidé, ne vous inquiétez pas. Le but de cette fonction est de vous permettre de commencer sans avoir à apprendre Lua. Voyons comment créer un nouveau mappage. Disons que vous voulez des raccourcis de touches fléchées Vim à l’échelle du système, activés par ctrl.

-- Définir les mappages
local maps = {
	[{ "ctrl" }] = {
		-- Touches fléchées
		["h"] = "left",
		["j"] = "down",
		["k"] = "up",
		["l"] = "right",
	},
}

-- Lier les mappages
processMaps(maps)

Mettez simplement cela à la fin du fichier, rechargez la configuration, et vos touches devraient être mappées !

Comment fonctionne maps

maps est un tableau, ou une liste de tables. Chaque table a un tableau de touches modificateurs comme clé, et une table qui mappe une touche à une autre touche comme valeur. Dans l’exemple ci-dessus, la seule touche modificateur est ctrl, ce qui signifie que tous les mappages dans sa table ne sont activés que lorsque ctrl est maintenu enfoncé. Ensuite, il mappe h à la flèche gauche, j à la flèche bas, etc.

Si vous ne comprenez toujours pas, ne vous inquiétez pas. Regardez simplement ces exemples et modifiez-les pour répondre à vos besoins.

Exemples

Voici quelques exemples supplémentaires de maps tables :

Mapper ctrl-n pour supprimer un mot, ctrl-m pour supprimer un caractère, ctrl-. pour supprimer un mot devant le curseur, et ctrl-, pour supprimer un caractère devant le curseur.

-- à l'intérieur de `maps`
[{ "ctrl" }] = {
	-- Suppression
	["n"] = "alt-delete",
	["m"] = "delete",
	[","] = "forwarddelete",
	["."] = "alt-forwarddelete",
},

Mapper les touches de fonction aux contrôles multimédias. Notez que celles-ci n’ont aucune touche modificateur, donc appuyer simplement sur f1 activera le mappage :

-- à l'intérieur de `maps`
[{}] = {
	-- Contrôles multimédias
	["f1"] = "MUTE",
	["f2"] = "SOUND_DOWN",
	["f3"] = "SOUND_UP",

	["f5"] = "PREVIOUS",
	["f6"] = "PLAY",
	["f7"] = "NEXT",
},

Rechargez votre configuration Hammerspoon avec alt-ctrl-r

-- à l'intérieur de `maps`
[{ "alt", "ctrl" }] = {
	-- Recharger la configuration Hammerspoon
	["r"] = hs.reload,
},

Mettez votre ordinateur portable en veille avec cmd-g

-- à l'intérieur de `maps`
[{ "cmd" }] = {
	["g"] = function()
		-- Cette fonction exécute une commande shell
		os.execute("pmset sleepnow")
	end,
},

Lancez l’application Obsidian avec cmd-shift-o

[{ "cmd", "shift" }] = {
	["o"] = function()
		hs.application.launchOrFocus("Obsidian")
	end,
},

N’oubliez pas d’exécuter processMaps(maps) après avoir tout défini !

local maps = {
	[{}] = {
		-- trucs
	},
	[{ "cmd" }] = {
		-- trucs
	},
	[{ "cmd", "shift" }] = {
		-- trucs
	},
	-- ...
}

processMaps(maps)

Conclusion

Hammerspoon est un outil extrêmement puissant. Une fois que vous vous serez familiarisé avec Lua, les possibilités sont infinies. Je me suis concentré sur les raccourcis clavier dans cet article car c’est ce que j’ai trouvé être le cas d’utilisation le plus important pour Hammerspoon.

Si vous voulez voir toutes les fonctions API que Hammerspoon expose, consultez leur documentation. Il y a une quantité absurde de choses que vous pouvez faire avec cette application—comme lier des événements à l’état de la batterie, changer la luminosité de l’écran, ouvrir des invites de dialogue, envoyer des requêtes HTTP, copier et coller, et cetera. En plus de cela, vous pouvez profiter de tout l’écosystème Lua via Luarocks.

Consultez également r/Hammerspoon pour voir ce que font les autres passionnés. Nous pourrions utiliser quelques membres supplémentaires là-bas :)

Liens utiles

Une collection de ressources liées à Hammerspoon. Je mettrai à jour cette liste au fur et à mesure que je découvre de nouvelles choses.