some more pain

files/.config/nvim/fnl/help-thingy.fnl

@@ -1,9 +1,10 @@
 (module help-thingy
-  {autoload {utils utils
+  {require {utils utils
-             a aniseed.core
+            a aniseed.core
-             str aniseed.string
+            str aniseed.string
-             fennel aniseed.fennel
+            fennel aniseed.fennel
-             popup popup}
+            popup popup
+            ts nvim-treesitter}
    require-macros [macros]})
 
 (defn get-current-word []
@@ -12,12 +13,13 @@
     (.. (vim.fn.matchstr (string.sub line 1 (+ col 1)) 
                          "\\k*$")
         (string.sub ( vim.fn.matchstr (string.sub line (+ col 1))
-                                     "^\\k*")
+                                      "^\\k*")
                     2))))
 
 
 
 (def helpfiles-path (str.join "/" (a.butlast (str.split vim.o.helpfile "/"))))
+
 (def tags
   (let [entries {}]
     (each [line _ (io.lines (.. helpfiles-path "/tags"))]
@@ -28,12 +30,12 @@
 (defn find-help-tag-for [topic]
   (or (. tags topic)
       (. tags (.. topic "()"))
-      (. tags (.. (string.gsub topic "vim.api." "") "()"))
+      (. tags (.. (string.gsub topic "vim%.api%." "") "()"))
-      (. tags (.. (string.gsub topic "vim.fn." "") "()"))
+      (. tags (.. (string.gsub topic "vim%.fn%." "") "()"))
-      (. tags (.. (string.gsub topic "fn." "") "()"))
+      (. tags (.. (string.gsub topic "fn%." "") "()"))
-      (. tags (.. (string.gsub topic "vim.o." "") "()"))
+      (. tags (.. (string.gsub topic "vim%.o%." "") "()"))
-      (. tags (.. (string.gsub topic "vim.b." "") "()"))
+      (. tags (.. (string.gsub topic "vim%.b%." "") "()"))
-      (. tags (.. (string.gsub topic "vim.g." "") "()"))))
+      (. tags (.. (string.gsub topic "vim%.g%." "") "()"))))
 
 
 (defn help-for-tag [tag]
@@ -50,14 +52,14 @@
         (table.insert data line)
         (lua "return data")))))
 
-(defn pop [text]
+(defn pop [text ft]
   (var width 0)
   (each [_ line (ipairs text)]
     (when (> (length line) width)
       (set width (length line))))
   (let [bufnr (vim.api.nvim_create_buf false true)]
     (vim.api.nvim_buf_set_option bufnr :bufhidden "wipe")
-    (vim.api.nvim_buf_set_option bufnr :filetype "help")
+    (vim.api.nvim_buf_set_option bufnr :filetype ft)
     (vim.api.nvim_buf_set_lines bufnr 0 -1 true text)
     (popup.create bufnr {:padding [1 1 1 1] :width width})))
 
@@ -65,15 +67,82 @@
 (fn _G.get_help []
   (let [help-tag (find-help-tag-for (get-current-word))]
     (when help-tag
-      (pop (help-for-tag help-tag)))))
+      (pop (help-for-tag help-tag) :help))))
 
+
+
+
+(def all-module-paths
+  (let [paths (str.split package.path ";")]
+    (each [_ path (ipairs (str.split vim.o.runtimepath ","))]
+      (table.insert paths (.. path "/fnl/?.fnl"))
+      (table.insert paths (.. path "/fnl/?/init.fnl"))
+      (table.insert paths (.. path "/lua/?.lua"))
+      (table.insert paths (.. path "/lua/?/init.lua")))
+    paths))
+
+
+(defn file-exists? [path]
+  (let [file (io.open path :r)]
+    (if (~= nil file)
+      (do (io.close file)
+        true)
+      false)))
+
+(defn find-module-path [module-name]
+  (let [module-name (module-name:gsub "%." "/")]
+    (utils.find-map #(utils.keep-if file-exists? ($1:gsub "?" module-name))
+                    all-module-paths)))
+
+
+(defn read-module-file [module-name]
+  (let [path (find-module-path module-name)]
+    (when path
+      (let [ft (match (string.gsub path ".+%.(%w+)" "%1")
+                 :fnl "fennel"
+                 :lua "lua")
+            result (icollect [line _ (io.lines path)]
+                     line)]
+        (values result ft)))))
+
+
+(defn gib-definition [mod word]
+  (let [(file-lines filetype) (read-module-file mod)
+        query (vim.treesitter.parse_query 
+                filetype
+                (.. "((identifier) @fuck (#contains? @fuck \"" word "\"))"))
+        bufnr (vim.api.nvim_create_buf false true)]
+    (vim.api.nvim_buf_set_lines bufnr 0 -1 true file-lines)
+    (let [parser (vim.treesitter.get_parser bufnr filetype)
+          [tstree] (parser:parse)
+          tsnode (tstree:root)
+          code-lines []]
+      (each [id node metadata (query:iter_captures tsnode bufnr 0 -1)]
+        (let [parent (node:parent)
+              (r1 c1 r2 c2) (parent:range)]
+          (for [i (+ r1 1) r2]
+            (table.insert code-lines (. file-lines i)))))
+      (pop code-lines filetype))))
+
+
+
+
+(fn _G.gib_def []
+  (let [word (get-current-word)
+        segs (str.split word "%.")]
+    (match segs
+      [mod ident] 
+      (gib-definition mod ident)
+
+      [ident] 
+      (let [[current-file] (str.split (vim.fn.expand "%:t") "%.")]
+        (gib-definition current-file ident)))))
+
+
+
+  ;(gib-definition "help-thingy" (ident)))
 (utils.keymap :n :L ":call v:lua.get_help()<CR>")
-
+(utils.keymap :n :N ":call v:lua.gib_def()<CR>")
-
-
-(def rtp vim.o.runtimepath)
-(str.split rtp ",")
-
 
 ; vim.api.nvim_buf_get_name
 ; vim.api.nvim_buf_call

files/.config/nvim/fnl/smart-compe-conjure.fnl

@@ -58,4 +58,6 @@
            :epic true}})
 
 
+
+
 ;(print (fennel.view compe))

files/.config/nvim/fnl/utils.fnl

@@ -9,7 +9,7 @@
   (~= nil (. packer_plugins name)))
 
 (defn all [f xs]
-  (not (a.some (not (f $1)))))
+  (not (a.some #(not (f $1)))))
 
 (defn single-to-list [x]
   "Returns the list given to it. If given a single value, wraps it in a list"
@@ -23,6 +23,22 @@
     (when (f k v)
       (values k v))))
 
+
+(defn find-where [pred xs]
+  (each [_ x (ipairs xs)]
+    (when (pred x)
+      (lua "return x"))))
+
+(defn find-map [f xs]
+  (each [_ x (ipairs xs)]
+    (let [res (f x)]
+      (when (~= nil res)
+        (lua "return res")))))
+
+(defn keep-if [f x]
+  (when (f x) x))
+
+
 (defn without-keys [keys t]
   (filter-table #(not (contains? keys $1)) t))