Spoonify Spacehammer

init.lua

@@ -1,12 +1,28 @@
-hs.alert.show("Spacehammer config loaded")
+local Spacehammer = {
+  name = "Spacehammer",
+  version = "3.0.0",
+  author = "Ag Ibragimov",
+  license = "MIT",
+  homepage = "https://github.com/agzam/spacehammer"
+}
 
--- Support upcoming 5.4 release and also use luarocks' local path
-package.path = package.path .. ";" .. os.getenv("HOME") .. "/.luarocks/share/lua/5.4/?.lua;" .. os.getenv("HOME") .. "/.luarocks/share/lua/5.4/?/init.lua"
-package.cpath = package.cpath .. ";" .. os.getenv("HOME") .. "/.luarocks/lib/lua/5.4/?.so"
-package.path = package.path .. ";" .. os.getenv("HOME") .. "/.luarocks/share/lua/5.3/?.lua;" .. os.getenv("HOME") .. "/.luarocks/share/lua/5.3/?/init.lua"
-package.cpath = package.cpath .. ";" .. os.getenv("HOME") .. "/.luarocks/lib/lua/5.3/?.so"
+function Spacehammer:init()
+  local scriptPath = hs.spoons.scriptPath()
 
-fennel = require("fennel")
-table.insert(package.loaders or package.searchers, fennel.searcher)
+  package.path = package.path .. ";" .. scriptPath .. "?.lua;" .. scriptPath .. "?/init.lua;"
+  package.cpath = package.cpath .. ";" .. scriptPath .. "?.so;"
 
-require "core"
+  fennel = require("spacehammer.vendor.fennel")
+  fennel.path = scriptPath .. "?.fnl;" .. scriptPath .. "?/init.fnl;" .. fennel.path
+  fennel['macro-path'] = scriptPath .. "?.fnl;" .. scriptPath .. "?/init-macros.fnl;" .. scriptPath .. "?/init.fnl;" .. fennel.path
+  print(hs.inspect(package.searchers))
+  table.insert(package.loaders or package.searchers, fennel.searcher)
+end
+
+function Spacehammer:start()
+  print(hs.inspect(package.searchers))
+  require('spacehammer.core')
+  hs.alert.show("Spacehammer config loaded")
+end
+
+return Spacehammer

apps.fnl → spacehammer/apps.fnl

@@ -1,4 +1,4 @@
-(local {: global-filter} (require :lib.utils))
+(local {: global-filter} (require :spacehammer.lib.utils))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; App switcher

chrome.fnl → spacehammer/chrome.fnl

@@ -1,4 +1,4 @@
-(require-macros :lib.macros)
+(require-macros :spacehammer.lib.macros)
 
 ;; setting conflicting Cmd+L (jump to address bar) keybinding to Cmd+Shift+L
 (fn open-location

config.example.fnl → spacehammer/config.example.fnl

@@ -1,12 +1,12 @@
-(require-macros :lib.macros)
-(require-macros :lib.advice.macros)
-(local windows (require :windows))
-(local emacs (require :emacs))
-(local slack (require :slack))
-(local vim (require :vim))
+(require-macros :spacehammer.lib.macros)
+(require-macros :spacehammer.lib.advice.macros)
+(local windows (require :spacehammer.windows))
+(local emacs (require :spacehammer.emacs))
+(local slack (require :spacehammer.slack))
+(local vim (require :spacehammer.vim))
 
 (local {:concat concat
-        :logf logf} (require :lib.functional))
+        :logf logf} (require :spacehammer.lib.functional))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; WARNING

core.fnl → spacehammer/core.fnl

@@ -1,17 +1,17 @@
 (hs.ipc.cliInstall) ; ensure CLI installed
 
-(local fennel (require :fennel))
-(require :lib.globals)
+(local fennel (require :spacehammer.vendor.fennel))
+(require :spacehammer.lib.globals)
 (local {:contains? contains?
         :for-each  for-each
         :map       map
         :merge     merge
         :reduce    reduce
         :split     split
-        :some      some} (require :lib.functional))
-(local atom (require :lib.atom))
-(require-macros :lib.macros)
-(require-macros :lib.advice.macros)
+        :some      some} (require :spacehammer.lib.functional))
+(local atom (require :spacehammer.lib.atom))
+(require-macros :spacehammer.lib.macros)
+(require-macros :spacehammer.lib.advice.macros)
 
 ;; Add compatability with spoons as the spoon global may not exist at
 ;; this point until a spoon is loaded. It will exist if a spoon is
@@ -155,6 +155,7 @@ Returns nil. This function causes side-effects.
   Returns nil
   "
   (when (some source-updated? files)
+    (hs.alert "Spacehammer reloaded")
     (hs.console.clearConsole)
     (hs.reload)))
 
@@ -213,13 +214,13 @@ Returns nil. This function causes side-effects.
 (local config (require :config))
 
 ;; Initialize our modules that depend on config
-(local modules [:lib.hyper
-                :vim
-                :windows
-                :apps
-                :lib.bind
-                :lib.modal
-                :lib.apps])
+(local modules [:spacehammer.lib.hyper
+                :spacehammer.vim
+                :spacehammer.windows
+                :spacehammer.apps
+                :spacehammer.lib.bind
+                :spacehammer.lib.modal
+                :spacehammer.lib.apps])
 
 (defadvice get-config-impl
            []

grammarly.fnl → spacehammer/grammarly.fnl

@@ -16,7 +16,7 @@
 
 (fn back-to-emacs
   []
-  (let [windows (require :windows)
+  (let [windows (require :spacehammer.windows)
         run-str (.. "/usr/local/bin/emacsclient"
                     " -e "
                     "'(with-current-buffer (window-buffer (selected-window)) "

lib/advice/init.fnl → spacehammer/lib/advice/init.fnl

@@ -2,8 +2,8 @@
 Advising API to register functions
 "
 
-(require-macros :lib.macros)
-(local fennel (require :fennel))
+(require-macros :spacehammer.lib.macros)
+(local fennel (require :spacehammer.vendor.fennel))
 (local {: contains?
         : compose
         : filter
@@ -14,7 +14,7 @@ Advising API to register functions
         : reduce
         : seq
         : slice
-        : split} (require :lib.functional))
+        : split} (require :spacehammer.lib.functional))
 
 (var advice {})
 (var advisable [])

lib/advice/macros.fnl → spacehammer/lib/advice/macros.fnl

@@ -18,7 +18,7 @@ Macros to create advisable functions or register advice for advisable functions
   (assert body1 "advisable function expected body")
   (let [fn-name-str (tostring fn-name)]
     `(local ,fn-name
-            (let [adv# (require :lib.advice)]
+            (let [adv# (require :spacehammer.lib.advice)]
               (adv#.make-advisable ,fn-name-str (fn ,args ,docstr ,body1 ,...))))))
 
 (fn afn
@@ -37,7 +37,7 @@ Macros to create advisable functions or register advice for advisable functions
   "
   (assert body1 "advisable function expected body")
   (let [fn-name-str (tostring fn-name)]
-    `(let [adv# (require :lib.advice)]
+    `(let [adv# (require :spacehammer.lib.advice)]
        (adv#.make-advisable ,fn-name-str (fn ,args ,body1 ,...)))))
 
 
@@ -58,7 +58,7 @@ Macros to create advisable functions or register advice for advisable functions
   (assert (= (type docstr) :string) "A docstr is required for defining advice")
   (assert body1 "advisable function expected body")
   `(local ,fn-name
-          (let [adv# (require :lib.advice)
+          (let [adv# (require :spacehammer.lib.advice)
                 target-fn# (fn ,fn-name ,args ,docstr ,body1 ,...)
                 advice-fn# (setmetatable
                             {}

lib/apps.fnl → spacehammer/lib/apps.fnl

@@ -7,19 +7,19 @@ for, versus switching between apps, versus exiting apps, versus activating apps.
 
 This module works mechanically similar to lib/modal.fnl.
 "
-(local atom (require :lib.atom))
-(local statemachine (require :lib.statemachine))
+(local atom (require :spacehammer.lib.atom))
+(local statemachine (require :spacehammer.lib.statemachine))
 (local os (require :os))
 (local {: call-when
         : find
         : merge
         : noop
         : tap}
-       (require :lib.functional))
+       (require :spacehammer.lib.functional))
 (local {:action->fn action->fn
         :bind-keys bind-keys}
-       (require :lib.bind))
-(local lifecycle (require :lib.lifecycle))
+       (require :spacehammer.lib.bind))
+(local lifecycle (require :spacehammer.lib.lifecycle))
 
 
 (local log (hs.logger.new "apps.fnl" "debug"))

lib/bind.fnl → spacehammer/lib/bind.fnl

@@ -1,8 +1,8 @@
-(local hyper (require :lib.hyper))
+(local hyper (require :spacehammer.lib.hyper))
 (local {: contains?
         : map
         : split}
-       (require :lib.functional))
+       (require :spacehammer.lib.functional))
 
 (local log (hs.logger.new "bind.fnl" "debug"))
 

lib/functional.fnl → spacehammer/lib/functional.fnl

@@ -125,6 +125,7 @@
      (set ct (+ ct 1))))
   ct)
 
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Reduce Primitives
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

lib/globals.fnl → spacehammer/lib/globals.fnl

@@ -1,5 +1,5 @@
-(local fennel (require :fennel))
-(local {: map} (require :lib.functional))
+(local fennel (require :spacehammer.vendor.fennel))
+(local {: map} (require :spacehammer.lib.functional))
 
 (global pprint
         (fn pprint

lib/hyper.fnl → spacehammer/lib/hyper.fnl

@@ -1,5 +1,5 @@
-(require-macros :lib.macros)
-(local {: find} (require :lib.functional))
+(require-macros :spacehammer.lib.macros)
+(local {: find} (require :spacehammer.lib.functional))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

lib/lifecycle.fnl → spacehammer/lib/lifecycle.fnl

@@ -1,4 +1,4 @@
-(local {: do-action} (require :lib.bind))
+(local {: do-action} (require :spacehammer.lib.bind))
 (local log (hs.logger.new "lifecycle.fnl" "debug"))
 
 

lib/modal.fnl → spacehammer/lib/modal.fnl

@@ -9,9 +9,9 @@ states defined in the table.
 Allows us to create the machinery for displaying, entering, exiting, and
 switching menus in one place which is then powered by config.fnl.
 "
-(local atom (require :lib.atom))
-(local statemachine (require :lib.statemachine))
-(local apps (require :lib.apps))
+(local atom (require :spacehammer.lib.atom))
+(local statemachine (require :spacehammer.lib.statemachine))
+(local apps (require :spacehammer.lib.apps))
 (local {: butlast
         : call-when
         : concat
@@ -23,13 +23,13 @@ switching menus in one place which is then powered by config.fnl.
         : join
         : map
         : merge}
-       (require :lib.functional))
+       (require :spacehammer.lib.functional))
 (local {:align-columns align-columns}
-       (require :lib.text))
+       (require :spacehammer.lib.text))
 (local {:action->fn action->fn
         :bind-keys bind-keys}
-       (require :lib.bind))
-(local lifecycle (require :lib.lifecycle))
+       (require :spacehammer.lib.bind))
+(local lifecycle (require :spacehammer.lib.lifecycle))
 
 (local log (hs.logger.new "modal.fnl" "debug"))
 (var fsm nil)
@@ -273,8 +273,8 @@ switching menus in one place which is then powered by config.fnl.
       (hs.alert.closeAll 0)
       (unbind-keys)
       (call-when stop-timeout)
-      (lifecycle.exit-menu state.context.menu)
-      )))
+      (lifecycle.exit-menu state.context.menu))))
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Menus, & Config Navigation
@@ -364,7 +364,7 @@ switching menus in one place which is then powered by config.fnl.
   Returns new updated modal state if we are leaving the current app.
   "
   (let [{:config config
-        :menu prev-menu} state.context]
+         :menu prev-menu} state.context]
     (if (= prev-menu.key config.key)
         nil
         (->menu state))))

lib/statemachine.fnl → spacehammer/lib/statemachine.fnl

@@ -38,15 +38,15 @@ the next transition.
 "
 
 
-(require-macros :lib.macros)
-(local atom (require :lib.atom))
+(require-macros :spacehammer.lib.macros)
+(local atom (require :spacehammer.lib.atom))
 (local {: butlast
         : call-when
         : concat
         : conj
         : last
         : merge
-        : slice} (require :lib.functional))
+        : slice} (require :spacehammer.lib.functional))
 
 
 (fn update-state

lib/testing/test-runner.fnl → spacehammer/lib/testing/test-runner.fnl

@@ -1,8 +1,8 @@
-(local fennel (require :fennel))
-(require :lib.globals)
+(local fennel (require :spacehammer.vendor.fennel))
+(require :spacehammer.lib.globals)
 (local {: map
         : slice
-        : pprint}  (require :lib.functional))
+        : pprint}  (require :spacehammer.lib.functional))
 
 (local homedir (os.getenv "HOME"))
 (local customdir (.. homedir "/.spacehammer"))
@@ -35,8 +35,8 @@
     (each [i test-file (ipairs test-files)]
       (let [test-file-path (hs.fs.pathToAbsolute (.. dir "/" test-file))]
         (print "Running tests for" test-file-path)
-        (fennel.dofile test-file-path))
-      ))
+        (fennel.dofile test-file-path))))
+
 
 
   (collect-tests)

spacehammer/lib/testing/test.lua

@@ -0,0 +1,15 @@
+--test.lua
+-- A script to run fennel files as tests passed in as cli args
+
+
+fennel = require("spacehammer.vendor.fennel")
+
+-- Support docstrings
+
+local searcher = fennel.makeSearcher({
+      useMetadata = true,
+})
+
+local testRunner = require "lib.testing.test-runner"
+
+testRunner["load-tests"](_cli.args)

lib/text.fnl → spacehammer/lib/text.fnl

@@ -1,5 +1,5 @@
 (local {: map
-        : reduce} (require :lib.functional))
+        : reduce} (require :spacehammer.lib.functional))
 
 "
 These functions will align items in a modal menu based on columns.

repl.fnl → spacehammer/repl.fnl

@@ -1,7 +1,7 @@
 (local coroutine (require :coroutine))
-(local fennel (require :fennel))
-(local jeejah (require :jeejah))
-(local {:merge merge} (require :lib.functional))
+(local fennel (require :spacehammer.vendor.fennel))
+(local jeejah (require :spacehammer.vendor.jeejah))
+(local {:merge merge} (require :spacehammer.lib.functional))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; nREPL support