Merge pull request #26 from clojure-vim/lua/wrapper

Lua/wrapper

Author: hkupty

rplugin/python3/acid/clj_fns/manage_requires.clj renamed to clj/acid/refactor/manage_requires.clj

@@ -1,3 +1,5 @@
+(ns acid.refactor.manage-requires)
+
 (defn manipulate-req [reqs modify]
   (let [[[h] v] (split-at 1 reqs)]
     (conj (sort-by first (modify v)) h)))

clj/acid/test/report.clj

@@ -0,0 +1,41 @@
+(ns acid.test.report
+  (:require [clojure.test :as ct]))
+
+(def ^:dynamic details nil)
+
+(defn- with-error [m k c]
+  (if (some? (k c))
+    (update c k conj m)
+    (assoc c k [m])))
+
+(defmulti acid-clj-test-report :type)
+
+(defmethod acid-clj-test-report :pass [m]
+  (ct/inc-report-counter :pass))
+
+(defmethod acid-clj-test-report :fail [m]
+  (ct/inc-report-counter :fail)
+  (swap! details (partial with-error m :failures)))
+
+(defmethod acid-clj-test-report :error [m]
+  (ct/inc-report-counter :error)
+  (swap! details (partial with-error m :errors)))
+
+(defmethod acid-clj-test-report :summary [m])
+
+(defmethod acid-clj-test-report :default [m])
+(defmethod acid-clj-test-report :begin-test-ns [m])
+(defmethod acid-clj-test-report :end-test-ns [m])
+(defmethod acid-clj-test-report :begin-test-var [m])
+(defmethod acid-clj-test-report :end-test-var [m])
+
+
+(defn run-n-tests [run-test-fn args]
+  (binding [ct/report acid-clj-test-report
+            details    (atom {})]
+    (-> (apply run-test-fn args)
+        (merge @details)
+        (dissoc :type))))
+
+(defn run-all-tests [] (run-n-tests ct/run-all-tests []))
+(defn run-tests     [& nss] (run-n-tests ct/run-tests nss))

lua/acid/init.lua

@@ -0,0 +1,23 @@
+-- luacheck: globals unpack vim
+local nvim = vim.api
+
+local indirection = {}
+local acid = {}
+
+acid.send = function(obj, handler)
+  local session = math.random(10000, 99999)
+
+  indirection[session] = handler
+
+  nvim.nvim_call_function("AcidSendNrepl", {
+      obj,
+      "LuaFn",
+      "require('acid').callback(" .. session .. ", _A)"
+    })
+end
+
+acid.callback = function(session, ret)
+  return indirection[session](ret)
+end
+
+return acid

rplugin/python3/acid/__init__.py

@@ -125,15 +125,16 @@ def acid_unset_session(self):
     def acid_command(self, args):
         cmd, *args = args
         log_info(r"Received args for command {}: {}", cmd, args)
+        command = self.extensions['commands'].get(cmd.strip())
+
         url = formatted_localhost_address(self.nvim)
 
-        if url is None:
+        if url is None and command.handlers:
             path = current_path(self.nvim)
             echo(self.nvim, "No REPL open")
             log_info("No repl open on path {}".format(path))
             return
 
-        command = self.extensions['commands'].get(cmd.strip())
         command.call(self, self.context(), *args)
 
     @neovim.function("AcidCommandMeta", sync=True)

rplugin/python3/acid/commands/__init__.py

@@ -31,11 +31,15 @@ def __init__(self, nvim):
     def on_init(self):
         pass
 
+    def on_configure(self, *args, **kwargs):
+        return []
+
     def prepare_payload(self, *args):
         return {}
 
     def configure(self, context, handler, *args):
-        handler.configure(*args, **context)
+        data = [*self.on_configure(*args, **context), *args]
+        handler.configure(*data, **context)
         return handler
 
     def start_handler(self, context, handler, *args):

rplugin/python3/acid/commands/describe_spec.py

@@ -0,0 +1,43 @@
+from acid.commands import BaseCommand
+from acid.pure.doc_fmt import doc_transform
+from acid.nvim import path_to_ns, log
+
+def tf(f):
+    if type(f) == list:
+        return ', '.join(f)
+    return f
+
+definition = {
+    'data': {
+        'spec-name': {},
+        'spec-form': {
+            'transform': lambda k: [
+                tf(i) for i in k
+            ]
+        },
+    },
+    'format': [
+        'spec-name',
+        [],
+        'spec-form'
+    ]
+}
+
+
+class Command(BaseCommand):
+
+    name = 'DescribeSpec'
+    priority = 0
+    nargs = 1
+    handlers = ['Doc']
+    op = "spec-form"
+    shorthand_mapping = 'css'
+    shorthand="call setreg('s', expand('<cword>'))"
+
+    def on_configure(self, *_a, **_k):
+        log.log_debug('Passing spec transformation fn')
+        return [doc_transform(definition)]
+
+    def prepare_payload(self, data):
+        return {'spec-name': data}
+

rplugin/python3/acid/commands/doc.py

@@ -1,5 +1,57 @@
 from acid.commands import BaseCommand
-from acid.nvim import path_to_ns
+from acid.nvim import path_to_ns, log
+from acid.pure.doc_fmt import doc_transform
+from collections import OrderedDict
+
+
+definition = {
+    'data': OrderedDict([
+        ['name', {}],
+        ['ns', {'default': ''}],
+        ['arglists-str', {
+            'default': [],
+            'rename': 'fn_calls',
+            'transform': lambda t, name: ' '.join([
+                '({}{})'.format(name, ' {}'.format(i) if i else '')
+                for i in t[2:-2].split('] [')
+            ])
+        }],
+        ['doc', {
+            'default': '',
+            'transform': lambda k: [i.strip() for i in k.split('\n')]
+        }],
+        ['javadoc', {'default': ''}],
+        ['added', {'default': '', 'transform': 'Since version: {}'.format}],
+        ['super', {'default': '', 'transform': 'Extends: {}'.format}],
+        ['modifiers', {'default': []}],
+        ['see-also', {
+            'default': [],
+            'prepend': 'See Also:',
+            'transform': lambda k: [
+                'https://clojuredocs.org/{}'.format(i)
+                for i in k
+            ]
+        }],
+        ['interfaces', {
+            'default': [],
+            'transform': lambda k: 'Implements: {}'.format(', '.join(k))
+        }]
+    ]),
+    'format': [
+        'fn_calls',
+        [],
+        'ns',
+        'modifiers',
+        [],
+        'javadoc',
+        'doc',
+        [],
+        'added',
+        'interfaces',
+        'super',
+        'see-also',
+    ]
+}
 
 
 class Command(BaseCommand):
@@ -12,6 +64,10 @@ class Command(BaseCommand):
     shorthand_mapping = 'K'
     shorthand="call setreg('s', expand('<cword>'))"
 
+    def on_configure(self, *_a, **_k):
+        log.log_debug('Passing doc transformation fn')
+        return [doc_transform(definition)]
+
     def prepare_payload(self, data):
         return {"symbol": data, "ns": path_to_ns(self.nvim)}
 

rplugin/python3/acid/commands/list_clj.py

@@ -0,0 +1,18 @@
+from acid.commands import BaseCommand
+from acid.nvim import list_clj_files
+import os
+
+def transform_path_to_ns(path):
+    return os.path.splitext(os.path.basename(path))[0].replace('_', '-')
+
+class Command(BaseCommand):
+
+    name = 'ListClj'
+    priority = 0
+    enabled = 0
+    nargs = 0
+    handlers = []
+    mapping = 'clf'
+
+    def prepare_payload(self, ns):
+        clj_files = [i for i in list_clj_files(self.nvim)]

rplugin/python3/acid/commands/load_file.py

@@ -0,0 +1,36 @@
+from acid.commands import BaseCommand
+from acid.nvim import list_clj_files, current_path, log
+from acid.pure import ns_to_path
+import os
+
+
+class Command(BaseCommand):
+
+    name = 'LoadFile'
+    priority = 0
+    handlers = ['Ignore']
+    nargs = 1
+    prompt = 1
+    op = "load-file"
+
+    def prepare_payload(self, ns):
+        files = list(list_clj_files(self.nvim))
+        path = '{}.clj'.format(ns_to_path(ns))
+
+        log.log_debug('Found all this clojure files: {}', files)
+        log.log_debug('Attempting to match against {}', path)
+
+        match = list(filter(lambda k: k.endswith(path), files))
+        if any(match):
+            fpath, *_ = match
+            fpath = os.path.relpath(fpath, start=current_path(self.nvim))
+            with open(fpath, 'r') as source:
+                data = '\n'.join(source.readlines())
+
+            return {
+                'file': data,
+                'file-path': fpath,
+                'file-name': os.path.basename(fpath)
+            }
+        else:
+            log.warning(self.nvim, 'no file found!')

rplugin/python3/acid/commands/new.py

@@ -26,6 +26,7 @@ def prepare_payload(self, ns):
         open_with = self.nvim.vars.get('acid_open_new_file_with', 'edit')
         path = os.path.join(current_path(self.nvim), base, fname)
         directory = os.path.dirname(path)
+
         if not os.path.exists(directory):
             os.makedirs(directory)
 

rplugin/python3/acid/commands/run_tests.py

@@ -0,0 +1,17 @@
+from acid.commands import BaseCommand
+from acid.nvim import get_acid_ns, find_clojure_fn
+import os
+
+
+class Command(BaseCommand):
+
+    name = 'RunTests'
+    priority = 0
+    enabled = 0
+    handlers = ['Ignore']
+    nargs='*'
+    op = "eval"
+    requires = ['acid.test.report']
+
+    def prepare_payload(self, *args):
+        pass

rplugin/python3/acid/commands/scratch.py

@@ -0,0 +1,47 @@
+from acid.commands import BaseCommand
+from acid.zen.ui import build_window
+from acid.nvim.log import warning
+import random
+import os
+
+
+class Command(BaseCommand):
+
+    name = 'Scratchpad'
+    priority = 0
+    nargs=0
+    handlers = []
+    mapping = 'csp'
+
+    @staticmethod
+    def prompt_default(nvim):
+        path = nvim.funcs.expand('%:p:h')
+        return "{}.".format(path_to_ns(path))
+
+
+    def prepare_payload(self):
+        send = "map <buffer> <silent> <localleader><CR> {}".format(
+            "".join(map(
+                str.strip,
+                """:call AcidSendNrepl({'op': 'eval',
+                'code': join(getline(1, '$'), '\\n')}, 'MetaRepl')
+                <CR>""".splitlines()
+            ))
+        )
+
+        cmds = ['file acid://scratch-buffer-{}'.format(random.randint(0, 100)),
+                'set ft=clojure',
+                'let b:acid_ns_strategy="ns:user"',
+                'nmap <buffer> <silent> q :bd! %<CR>',
+                send,
+                ]
+
+
+        build_window(
+            self.nvim,
+            throwaway=1,
+            orientation="rightbelow 20 split",
+            commands=cmds,
+        )
+
+        return None

rplugin/python3/acid/handlers/__init__.py

@@ -27,6 +27,7 @@ def __init__(self):
     def configure(self, *args, **kwargs):
         self.nvim = kwargs['nvim']
         self.context = kwargs
+        self.on_configure(*args, **kwargs)
         return self
 
     def new_child_handler(self, handler):
@@ -43,6 +44,9 @@ def pass_to(self, msg, handler):
     def on_init(self):
         pass
 
+    def on_configure(self, *_a, **_k):
+        pass
+
     def on_pre_send(self, *_):
         pass
 

rplugin/python3/acid/handlers/doautocmd.py

@@ -10,10 +10,8 @@ def on_init(self):
         self.cmd_group = ""
         self.successful = True
 
-    def configure(self, cmd_group, *args, **kwargs):
-        super().configure(*args, **kwargs)
+    def on_configure(self, cmd_group, *args, **kwargs):
         self.cmd_group = cmd_group
-        return self
 
     def on_handle(self, msg, *_):
         self.successful = self.successful and not 'err' in msg