hs: new indentation style

hammerspoon/apps/finder.lua

@@ -1,5 +1,5 @@
 
 App.new("Finder")
-    .onActivate(function(self, app)
+   .onActivate(function(self, app)
-        app:selectMenuItem({"Window", "Bring All to Front"})
+     app:selectMenuItem({"Window", "Bring All to Front"})
-    end)
+   end)

hammerspoon/bindings.lua

@@ -14,19 +14,19 @@ function commandMode:exited()  overlay:hide() end
 
 -- Command mode keybindings
 hs.fnutils.each({
-    { '',      'escape', util.call(commandMode, 'exit') },
+  { '',      'escape', util.call(commandMode, 'exit') },
-    { '',      'r',      util.reload },
+  { '',      'r',      util.reload },
-    { 'shift', 'r',      function() hs.openConsole(); commandMode:exit() end },
+  { 'shift', 'r',      function() hs.openConsole(); commandMode:exit() end },
 }, function (item)
-    commandMode:bind(item[1], item[2], item[3])
+  commandMode:bind(item[1], item[2], item[3])
 end)
 
 -- Global keybindings
 hs.fnutils.each({
-    -- { {'cmd', 'ctrl'}, 'up',    function() print("UP"); modes.position:enter() end },
+  -- { {'cmd', 'ctrl'}, 'up',    function() print("UP"); modes.position:enter() end },
-    -- { {'cmd', 'ctrl'}, 'left',  function() print("LEFT"); resizeBRMode:enter() end },
+  -- { {'cmd', 'ctrl'}, 'left',  function() print("LEFT"); resizeBRMode:enter() end },
-    -- { {'cmd', 'ctrl'}, 'right', function() print("RIGHT"); resizeTLMode:enter() end },
+  -- { {'cmd', 'ctrl'}, 'right', function() print("RIGHT"); resizeTLMode:enter() end },
 }, function (item)
-    hs.hotkey.bind(item[1], item[2], item[3])
+  hs.hotkey.bind(item[1], item[2], item[3])
 end)
 

hammerspoon/modules/apps.lua

@@ -3,123 +3,123 @@ local apps = {}
 -- App-specific code, runs when you launch or switch to another app
 App = {}
 App.new = function(name)
-    local self = {}
+  local self = {}
-    self.name = name
+  self.name = name
-    self.bindings = {}
+  self.bindings = {}
 
-    self.onInitFn = nil
+  self.onInitFn = nil
-    self.onActivateFn = nil
+  self.onActivateFn = nil
-    self.onDeactivateFn = nil
+  self.onDeactivateFn = nil
-    self.onLaunchedFn = nil
+  self.onLaunchedFn = nil
-    self.onTerminatedFn = nil
+  self.onTerminatedFn = nil
 
-    self.bind = function(mods, key, action, predicate)
+  self.bind = function(mods, key, action, predicate)
-        table.insert(self.bindings,
+    table.insert(self.bindings,
-                     {key = hs.hotkey.new(mods, key, action), predicate = predicate})
+                 {key = hs.hotkey.new(mods, key, action), predicate = predicate})
-        return self
-    end
-
-    self.onInit = function(fn)
-        fn(self)
-        return self
-    end
-    self.onActivate = function(fn)
-        self.onActivateFn = fn
-        return self
-    end
-    self.onDeactivate = function(fn)
-        self.onDeactivateFn = fn
-        return self
-    end
-    self.onLaunched = function(fn)
-        self.onLaunchedFn = fn
-        return self
-    end
-    self.onTerminated = function(fn)
-        self.onTerminatedFn = fn
-        return self
-    end
-
-    self.activate = function(appObject)
-        if type(self.onActivateFn) == 'function' then
-            self:onActivateFn(appObject)
-        end
-        self:enableBinds()
-    end
-    self.deactivate = function(appObject)
-        if type(self.onDeactivateFn) == 'function' then
-            self:onDeactivateFn(appObject)
-        end
-        self:disableBinds()
-    end
-    self.launch = function(appObject)
-        if type(self.onLaunchedFn) == 'function' then
-            self:onLaunchedFn(appObject)
-        end
-    end
-    self.terminate = function(appObject)
-        if type(self.onTerminatedFn) == 'function' then
-            self:onTerminatedFn(appObject)
-        end
-        self:clearBinds()
-    end
-
-    self.enableBinds = function(self)
-        hs.fnutils.each(self.bindings, function(b)
-            if b.predicate and not b.predicate() then
-                b.key:disable()
-            else
-                b.key:enable()
-            end
-        end)
-    end
-
-    self.disableBinds = function(self)
-        hs.fnutils.each(self.bindings, function(b) b.key:disable() end)
-    end
-
-    self.clearBinds = function(self)
-        hs.fnutils.each(self.bindings, function(b) b.key:delete() end)
-        self.bindings = {}
-    end
-
-    apps[name] = self
     return self
+  end
+
+  self.onInit = function(fn)
+    fn(self)
+    return self
+  end
+  self.onActivate = function(fn)
+    self.onActivateFn = fn
+    return self
+  end
+  self.onDeactivate = function(fn)
+    self.onDeactivateFn = fn
+    return self
+  end
+  self.onLaunched = function(fn)
+    self.onLaunchedFn = fn
+    return self
+  end
+  self.onTerminated = function(fn)
+    self.onTerminatedFn = fn
+    return self
+  end
+
+  self.activate = function(appObject)
+    if type(self.onActivateFn) == 'function' then
+      self:onActivateFn(appObject)
+    end
+    self:enableBinds()
+  end
+  self.deactivate = function(appObject)
+    if type(self.onDeactivateFn) == 'function' then
+      self:onDeactivateFn(appObject)
+    end
+    self:disableBinds()
+  end
+  self.launch = function(appObject)
+    if type(self.onLaunchedFn) == 'function' then
+      self:onLaunchedFn(appObject)
+    end
+  end
+  self.terminate = function(appObject)
+    if type(self.onTerminatedFn) == 'function' then
+      self:onTerminatedFn(appObject)
+    end
+    self:clearBinds()
+  end
+
+  self.enableBinds = function(self)
+    hs.fnutils.each(self.bindings, function(b)
+                      if b.predicate and not b.predicate() then
+                        b.key:disable()
+                      else
+                        b.key:enable()
+                      end
+    end)
+  end
+
+  self.disableBinds = function(self)
+    hs.fnutils.each(self.bindings, function(b) b.key:disable() end)
+  end
+
+  self.clearBinds = function(self)
+    hs.fnutils.each(self.bindings, function(b) b.key:delete() end)
+    self.bindings = {}
+  end
+
+  apps[name] = self
+  return self
 end
 
 function invoke(keys, predicate)
-    return function ()
+  return function ()
-        if predicate and not predicate() then
+    if predicate and not predicate() then
-            return
+      return
-        end
-        if type(keys) == 'table' then
-            hs.fnutils.each(keys, function (key)
-                if type(key) ~= 'table' then
-                    key = {{}, key}
-                end
-                hs.eventtap.keyStroke(key[1], key[2])
-            end)
-        elseif type(keys) == 'string' then
-            os.execute(keys)
-        elseif type(keys) == 'function' then
-            return keys()
-        end
     end
+    if type(keys) == 'table' then
+      hs.fnutils.each(keys, function (key)
+                        if type(key) ~= 'table' then
+                          key = {{}, key}
+                        end
+                        hs.eventtap.keyStroke(key[1], key[2])
+      end)
+    elseif type(keys) == 'string' then
+      os.execute(keys)
+    elseif type(keys) == 'function' then
+      return keys()
+    end
+  end
 end
 
 --
 function appGlobalWatcher(appName, eventType, appObject)
-    if apps[appName] then
+  if apps[appName] then
-        if (eventType == hs.application.watcher.activated) then
+    if (eventType == hs.application.watcher.activated) then
-            apps[appName].activate(appObject)
+      apps[appName].activate(appObject)
-        elseif (eventType == hs.application.watcher.deactivated) then
+    elseif (eventType == hs.application.watcher.deactivated) then
-            apps[appName].deactivate(appObject)
+      apps[appName].deactivate(appObject)
-        elseif (eventType == hs.application.watcher.launched) then
+    elseif (eventType == hs.application.watcher.launched) then
-            apps[appName].launch(appObject)
+      apps[appName].launch(appObject)
-        elseif (eventType == hs.application.watcher.terminated) then
+    elseif (eventType == hs.application.watcher.terminated) then
-            apps[appName].terminate(appObject)
+      apps[appName].terminate(appObject)
-        end
     end
+  end
 end
 hs.application.watcher.new(appGlobalWatcher):start()