start composing

8 files changed, 205 insertions, 137 deletions

diff --git a/fnl/conf/exctl/builder.fnl b/fnl/conf/exctl/builder.fnl
new file mode 100644
index 0000000..eb02b2b
--- /dev/null
+++ b/fnl/conf/exctl/builder.fnl
@@ -0,0 +1,76 @@
+(tset package.loaded :conf.exctl.frames.frame nil)
+(local vec (require :conf.exctl.frames.vec))
+(local frame (require :conf.exctl.frames.frame))
+(local m {})
+
+;; Creates a new painter that wraps the paint and close methods of a painter
+(local transform-painter (fn [painter ori width height]
+                           (fn [frm]
+                             (local coord (frame.frame->coord frm))
+                             (local new-ori (coord ori))
+                             (local new-frame
+                                    (frame new-ori
+                                           (vec.sub (coord width) new-ori)
+                                           (vec.sub (coord height) new-ori)))
+                             (painter new-frame))))
+
+(local pad (fn [painter pad-size]
+             (fn [frm]
+               (local pad-width (/ pad-size (frame.width frm)))
+               (local pad-height (/ pad-size (frame.height frm)))
+               (local transformed
+                      (transform-painter painter (vec.vec pad-width pad-height)
+                                         (vec.vec (- 1 pad-width) pad-height)
+                                         (vec.vec pad-width (- 1 pad-height))))
+               (transformed frm))))
+
+(local builder {})
+;;
+(fn builder.For [self partial-painter ...]
+  (table.insert self.partial-painters partial-painter)
+  self)
+
+(fn builder.Padding [self size]
+  (table.insert self.partial-painters {:op :pad : size})
+  self)
+
+(fn builder.Beside [self partial-builder]
+  (table.insert self.partial-painters {:op :beside : partial-builder})
+  self)
+
+(fn builder.build-painter [self effects]
+  (accumulate [painter (fn [frame] (print :leaf-painter)) _ partial-painter (ipairs self.partial-painters)]
+    (do
+      (match partial-painter
+        {:op :pad : size} (do
+                            (pad painter size))
+        {:op :beside : partial-builder} (do
+                                          (P (partial-builder:build-painter effects))
+                                          painter)
+        {: maps : buffer} (do
+                            (local window (effects:new-window maps))
+                            (local painter-ptr painter)
+                            (fn [frm]
+                              (local frame-opts
+                                     (frame.frame->open-win-options frm))
+                              (local buf (buffer))
+                              (if (not (window:open?))
+                                  (window:open buf frame-opts)
+                                  (window:repaint buf frame-opts))
+                              (painter-ptr frm)))
+        _ painter))))
+
+(fn builder.Build [self effects]
+  ;; TODO(mike): probably nice to model effects as pub sub pattern to make it rely less on references to mutable tables.
+  (local painter (self:build-painter effects))
+  (fn [frm]
+    (effects:attach)
+    (painter frm)))
+
+(fn builder.new [self]
+  (local bldr {:partial-painters []})
+  (setmetatable bldr self)
+  (set self.__index self)
+  bldr)
+
+builder
diff --git a/fnl/conf/exctl/effects.fnl b/fnl/conf/exctl/effects.fnl
new file mode 100644
index 0000000..160fbce
--- /dev/null
+++ b/fnl/conf/exctl/effects.fnl
@@ -0,0 +1,76 @@
+(local m {})
+(local window {})
+
+(local aug vim.api.nvim_create_augroup)
+(local del-aug vim.api.nvim_del_augroup_by_id)
+(local au vim.api.nvim_create_autocmd)
+(local winvar (fn [...] (pcall vim.api.nvim_win_get_var ...)))
+(local unmap (fn [{: mode : lhs : opts}] (pcall vim.keymap.del mode lhs opts)))
+(local map (fn [mode lhs rhs opts] (vim.keymap.set mode lhs rhs opts)))
+
+(fn window.close [self]
+  (if (self:open?)
+      (set self.handle (vim.api.nvim_win_close self.handle true))))
+
+(fn window.open [self buf frame]
+  (set frame.style :minimal)
+  (set self.handle (vim.api.nvim_open_win buf false frame))
+  (vim.api.nvim_win_set_var self.handle :effect-window self)
+  (if self.enter
+      (vim.api.nvim_set_current_win self.handle)))
+
+(fn window.id [self]
+  self.handle)
+
+(fn window.open? [self]
+  (if self.handle
+      (vim.api.nvim_win_is_valid self.handle) false))
+
+(fn window.new [self i enter maps]
+  (local w (setmetatable {: i : enter : maps} window))
+  (set self.__index self)
+  w)
+
+(fn m.new-window [self maps]
+  (local w (window:new (+ (length self.windows) 1) (= (length self.windows) 0)
+                       maps))
+  (table.insert self.windows w)
+  w)
+
+(fn m.close [self]
+  (each [_ w (ipairs self.windows)]
+    (w:close))
+  (if self.augroup
+      (set self.augroup (del-aug self.augroup)))
+  (if self.unmap
+      (set self.unmap (self.unmap))))
+
+(fn m.attach [self]
+  (set self.augroup (aug :EffectsMgr {:clear true}))
+  (au [:WinEnter :BufEnter]
+      {:group self.augroup
+       :pattern "*"
+       :callback (fn [cb-info]
+                   (local (ok? win) (winvar 0 :effect-window))
+                   (if (not ok?)
+                       (self:close)
+                       (do
+                         (if win.maps
+                             (self:win-maps win)))))}))
+
+(fn m.win-maps [self win]
+  (if self.unmap
+      (self.unmap))
+  (set self.unmap (fn []
+                    (each [_ m (ipairs win.maps)]
+                      (unmap m))))
+  (each [_ {: mode : lhs : rhs : opts} (ipairs win.maps)]
+    (map mode lhs (rhs self win) opts)))
+
+(fn m.new [self opts]
+  (local effects {:windows []})
+  (setmetatable effects self)
+  (set self.__index self)
+  effects)
+
+m
diff --git a/fnl/conf/exctl/frames/frame.fnl b/fnl/conf/exctl/frames/frame.fnl
index f74e88d..e7cd1e9 100644
--- a/fnl/conf/exctl/frames/frame.fnl
+++ b/fnl/conf/exctl/frames/frame.fnl
@@ -30,10 +30,6 @@
 
 (fn m.frame->coord [f]
   (fn [v]
-    (P :a (vec.scale (v:x-coord) (f:width-edge)))
-    (P :b (vec.scale (v:y-coord) (f:height-edge)))
-    (P :added (vec.add (vec.scale (v:x-coord) (f:width-edge))
-                       (vec.scale (v:y-coord) (f:height-edge))))
     (vec.add (f:origin)
              (vec.add (vec.scale (v:x-coord) (f:width-edge))
                       (vec.scale (v:y-coord) (f:height-edge))))))
@@ -51,11 +47,12 @@
   (local ori (f:origin))
   (local width-edge (f:width-edge))
   (local height-edge (f:height-edge))
+  (local anchor (or anchor :NW))
   {:width (width-edge:x-coord)
    :height (height-edge:y-coord)
    :col (ori:x-coord)
    :row (ori:y-coord)
-   :anchor :NW
+   : anchor
    :relative :editor})
 
 (setmetatable m {:__call (fn [self ...]
diff --git a/fnl/conf/exctl/init.fnl b/fnl/conf/exctl/init.fnl
index 5248707..0e07bba 100644
--- a/fnl/conf/exctl/init.fnl
+++ b/fnl/conf/exctl/init.fnl
@@ -1,16 +1,28 @@
+(tset package.loaded :conf.exctl.frames.vec nil)
 (local vec (require :conf.exctl.frames.vec))
+
+(tset package.loaded :conf.exctl.frames.frame nil)
 (local frame (require :conf.exctl.frames.frame))
-(tset package.loaded :conf.exctl.painters.buf nil)
-(local buf-painter (require :conf.exctl.painters.buf))
-(tset package.loaded :conf.exctl.painters nil)
-(local painter (require :conf.exctl.painters))
 
-(local root-frame (frame (vec.vec 0 0)
-                         (vec.vec vim.o.columns 0)
+(tset package.loaded :conf.exctl.builder nil)
+(local builder (require :conf.exctl.builder))
+
+(tset package.loaded :conf.exctl.effects nil)
+(local effects (require :conf.exctl.effects))
+
+(local root-frame (frame (vec.vec 0 0) (vec.vec vim.o.columns 0)
                          (vec.vec 0 vim.o.lines)))
 
-(local output (buf-painter (fn [] [0])))
-(local padded-output (painter.pad output 5))
-(local b (painter.beside padded-output padded-output))
+(local painter (-> (builder:new)
+                   (builder.For {:buffer (fn [] 0)
+                                 :maps [{:mode [:n :v :o]
+                                         :lhs :q
+                                         :rhs (fn [effects window]
+                                                (fn []
+                                                  (effects:close)))}]})
+                   (builder.Padding 5)
+                   (builder.Beside (-> (builder:new)
+                                       (builder.For {:buffer (fn [] 0)})))
+                   (builder.Build (effects:new))))
 
-(b:paint root-frame)
+(painter root-frame)
diff --git a/fnl/conf/exctl/painters.fnl b/fnl/conf/exctl/painters.fnl
deleted file mode 100644
index 95fe644..0000000
--- a/fnl/conf/exctl/painters.fnl
+++ /dev/null
@@ -1,50 +0,0 @@
-(local vec (require :conf.exctl.frames.vec))
-(local exctl-frame (require :conf.exctl.frames.frame))
-(local m {})
-
-;; Creates a new painter that wraps the paint and close methods of a painter
-(fn m.transform-painter [painter ori width height]
-  (painter:transform (fn [self frame]
-                       (local coord (exctl-frame.frame->coord frame))
-                       (local new-ori (coord ori))
-                       (P :new-ori new-ori)
-                       (local new-frame
-                              (exctl-frame new-ori
-                                           (vec.sub (coord width) new-ori)
-                                           (vec.sub (coord height) new-ori)))
-                       (P new-frame)
-                       (painter.paint self new-frame))
-                     painter.close))
-
-(fn m.pad [painter pad-size]
-  (painter:transform (fn [self frame]
-                       (local pad-width (/ pad-size (exctl-frame.width frame)))
-                       (local pad-height
-                              (/ pad-size (exctl-frame.height frame)))
-                       (P :width pad-width)
-                       (P :height pad-height)
-                       (local transformed
-                              (m.transform-painter painter
-                                                   (vec.vec pad-width
-                                                            pad-height)
-                                                   (vec.vec (- 1 pad-width)
-                                                            pad-height)
-                                                   (vec.vec pad-width
-                                                            (- 1 pad-height))))
-                       (transformed.paint self frame))))
-
-(fn m.beside [p1 p2]
-  {:paint (fn [self frame]
-            (local new-p1
-                   (m.transform-painter p1 (vec.vec 0 0) (vec.vec 0.5 0)
-                                        (vec.vec 0 1)))
-            (local new-p2
-                   (m.transform-painter p2 (vec.vec 0.5 0) (vec.vec 1 0)
-                                        (vec.vec 0.5 1)))
-            (new-p1:paint frame)
-            (new-p2:paint frame))
-   :close (fn []
-            (p1:close)
-            (p2:close))})
-
-m
diff --git a/fnl/conf/exctl/painters/buf.fnl b/fnl/conf/exctl/painters/buf.fnl
deleted file mode 100644
index 07694c6..0000000
--- a/fnl/conf/exctl/painters/buf.fnl
+++ /dev/null
@@ -1,25 +0,0 @@
-(local {: frame->open-win-options} (require :conf.exctl.frames.frame))
-(local buf {})
-
-;; Paint procedure takes a frame to create a neovim window and populate the winbar and buffer of the window
-;; frame is max height and width the painter can use
-;; { height = number, width = number }
-(fn buf.paint [self frame]
-  (local open (or self.window false))
-  (assert (not open)
-          "Expect window not open, because i need to implement the closed paint case first")
-  (vim.api.nvim_open_win 0 true (frame->open-win-options frame)))
-
-(fn buf.transform [self paint]
-  (buf.new {: self.fetch-buffers : paint}))
-
-;; Buffer painters paints the window that is used to manage buffers where jobs put their output
-;; (fn fetch-buffers [] ...) -> [buffers...]
-(fn buf.new [self painter]
-  (setmetatable painter self)
-  (set self.__index self)
-  painter)
-
-;; Fancy lua way to create a new instance of the buf painter obj
-(fn [fetch-buffers]
-  (buf:new {: fetch-buffers :frames []}))
diff --git a/fnl/conf/exctl/spec.fnl b/fnl/conf/exctl/spec.fnl
deleted file mode 100644
index 71e18d0..0000000
--- a/fnl/conf/exctl/spec.fnl
+++ /dev/null
@@ -1,42 +0,0 @@
-;; (local a (require :plenary.async))
-;;
-;; (local back2vim (a.wrap vim.schedule 1))
-;;
-;; (fn read_file [path]
-;;   (local fd (a.uv.fs_open path :r 438))
-;;   (back2vim)
-;;   (vim.notify (vim.inspect fd)))
-;;
-;; (local f (.. (os.getenv :HOME) :/test))
-;;
-;; (a.run (fn []
-;;          (read_file f)))
-(tset package.loaded :conf.exctl.frames.vec nil)
-(local vec (require :conf.exctl.frames.vec))
-(local test-vec (vec.vec 0 1))
-(test-vec:x-coord)
-(test-vec:y-coord)
-(vec.sub test-vec (vec.vec 1 0))
-(vec.add test-vec (vec.vec 1 0))
-(vec.scale 3 test-vec)
-
-(tset package.loaded :conf.exctl.frames.frame nil)
-(local frame (require :conf.exctl.frames.frame))
-(local root-frame (frame (vec.vec 0 0) (vec.vec vim.o.columns 0)
-                         (vec.vec 0 vim.o.lines)))
-
-(root-frame:origin)
-(root-frame:height-edge)
-(root-frame:width-edge)
-(frame.frame->open-win-options root-frame)
-
-(tset package.loaded :conf.exctl.painters.buf nil)
-(local buf-painter (require :conf.exctl.painters.buf))
-(local test (buf-painter (fn [] [0])))
-
-;; {: height
-;;                                  : width
-;;                                  :relative :editor
-;;                                  :anchor :NW
-;;                                  :row (math.floor (* vim.o.lines 0.7))
-;;                                  :col 0.2])))
diff --git a/fnl/conf/pkgs/harpoon.fnl b/fnl/conf/pkgs/harpoon.fnl
index 5f15de0..8d6138b 100644
--- a/fnl/conf/pkgs/harpoon.fnl
+++ b/fnl/conf/pkgs/harpoon.fnl
@@ -9,8 +9,32 @@
 (vim.keymap.set :n "][" (make-harpoon (fn [] (harpoon-ui.toggle_quick_menu))))
 (vim.keymap.set :n "]]" (make-harpoon (fn [] (harpoon-ui.nav_next))))
 (vim.keymap.set :n "[[" (make-harpoon (fn [] (harpoon-ui.nav_prev))))
-(vim.keymap.set :n "[+" (make-harpoon (fn [] (harpoon-ui.nav_file 1))))
-(vim.keymap.set :n "[-" (make-harpoon (fn [] (harpoon-ui.nav_file 2))))
-(vim.keymap.set :n "[<" (make-harpoon (fn [] (harpoon-ui.nav_file 3))))
-(vim.keymap.set :n "[>" (make-harpoon (fn [] (harpoon-ui.nav_file 4))))
-(vim.keymap.set :n "[\"" (make-harpoon (fn [] (harpoon-ui.nav_file 5))))
+
+(var use-numbers false)
+(local num [1 2 3 4 5])
+(local shortcuts ["+" "-" "<" ">" "\""])
+(fn print-use-numbers []
+  (print (vim.inspect use-numbers)))
+
+(fn toggle-harpoon-mappings []
+  (print-use-numbers)
+  (if (not use-numbers)
+      (do
+        ; (each [_ i (ipairs shortcuts)] ;   (vim.keymap.del :n i))
+        (vim.keymap.set :n "[+" (make-harpoon (fn [] (harpoon-ui.nav_file 1))))
+        (vim.keymap.set :n "[-" (make-harpoon (fn [] (harpoon-ui.nav_file 2))))
+        (vim.keymap.set :n "[<" (make-harpoon (fn [] (harpoon-ui.nav_file 3))))
+        (vim.keymap.set :n "[>" (make-harpoon (fn [] (harpoon-ui.nav_file 4))))
+        (vim.keymap.set :n "[\"" (make-harpoon (fn [] (harpoon-ui.nav_file 5))))
+        (set use-numbers true))
+      (do
+        ; (each [_ s (ipairs shortcuts)] ;   (vim.keymap.del :n s)
+        (vim.keymap.set :n "[1" (make-harpoon (fn [] (harpoon-ui.nav_file 1))))
+        (vim.keymap.set :n "[2" (make-harpoon (fn [] (harpoon-ui.nav_file 2))))
+        (vim.keymap.set :n "[3" (make-harpoon (fn [] (harpoon-ui.nav_file 3))))
+        (vim.keymap.set :n "[4" (make-harpoon (fn [] (harpoon-ui.nav_file 4))))
+        (vim.keymap.set :n "[5" (make-harpoon (fn [] (harpoon-ui.nav_file 5))))
+        (set use-numbers false))))
+
+(vim.api.nvim_create_user_command :H toggle-harpoon-mappings {})
+(toggle-harpoon-mappings)