Refactoring code checking

klen · klen · commit e10c7f71db06 · 2013-05-06T15:47:23.000+08:00
diff --git a/autoload/pymode/lint.vim b/autoload/pymode/lint.vim
@@ -15,6 +15,7 @@ fun! pymode#lint#Check() "{{{
     let g:pymode_lint_buffer = bufnr('%')
 
     py from pymode import lint
+    py queue.stop_queue(False)
     py lint.check_file()
 
 endfunction " }}}
diff --git a/ftplugin/python/init-pymode.vim b/ftplugin/python/init-pymode.vim
@@ -1,7 +1,6 @@
-if exists('did_init_pymode_vim')
+if pymode#Default('g:pymode_init', 1)
     finish
 endif
-let did_init_pymode_vim = 1
 
 let g:pymode_version = "0.6.17"
 
diff --git a/pylibs/pymode/interface.py b/pylibs/pymode/interface.py
@@ -18,7 +18,7 @@ def get_current_buffer():
 
 
 def show_message(message):
-    vim.command("call pymode#WideMessage('%s')" % message)
+    vim.command("call pymode#WideMessage('{0}')".format(message))
 
 
 def command(cmd):
diff --git a/pylibs/pymode/lint.py b/pylibs/pymode/lint.py
@@ -28,37 +28,36 @@ def check_file():
         if s
     ])
 
-    buffer = get_current_buffer()
+    buf = get_current_buffer()
     complexity = int(get_option('lint_mccabe_complexity') or 0)
 
-    add_task(run_checkers, checkers=checkers, ignore=ignore,
-             title='Code checking',
-             callback=parse_result,
-             buffer=buffer,
-             select=select,
-             complexity=complexity)
+    add_task(
+        run_checkers,
+        callback=parse_result,
+        title='Code checking',
 
+        checkers=checkers,
+        ignore=ignore,
+        buf=buf,
+        select=select,
+        complexity=complexity)
 
-def run_checkers(task=None, checkers=None, ignore=None,
-        buffer=None, select=None, complexity=None):
 
-    buffer = (task and task.buffer) or buffer
-    filename = buffer.name
+def run_checkers(checkers=None, ignore=None, buf=None, select=None,
+                 complexity=None, callback=None):
+
+    filename = buf.name
     result = []
 
     pylint_options = '--rcfile={0} -r n'.format(get_var('lint_config')).split()
 
-    result = run(filename, ignore=ignore, select=select, linters=checkers,
+    return run(filename, ignore=ignore, select=select, linters=checkers,
                  pylint=pylint_options, complexity=complexity)
 
-    if task:
-        task.result = result
-        task.finished = True
-        task.done = 100
-
 
-def parse_result(result, bnum):
-    command(('let g:qf_list = {0}'.format(repr(result)).replace('\': u', '\': ')))
-    command('call pymode#lint#Parse({0})'.format(bnum))
+def parse_result(result, buf=None, **kwargs):
+    command(('let g:qf_list = {0}'.format(repr(result)).replace(
+        '\': u', '\': ')))
+    command('call pymode#lint#Parse({0})'.format(buf.number))
 
 # pymode:lint_ignore=W0622
diff --git a/pylibs/pymode/queue.py b/pylibs/pymode/queue.py
@@ -1,60 +1,70 @@
 import threading
+from Queue import Queue, Empty
+
 from .interface import show_message
-import time
+
+
+MAX_LIFE = 60
+CHECK_INTERVAL = .2
+RESULTS = Queue()
 
 
 class Task(threading.Thread):
 
-    def __init__(self, buffer, callback=None, title=None, *args, **kwargs):
-        self.buffer = buffer
-        self._stop = threading.Event()
-        self.result = None
-        self.callback = callback
-        self.done = 0
-        self.finished = False
-        self.title = title
+    def __init__(self, *args, **kwargs):
+        self.stop = threading.Event()
         threading.Thread.__init__(self, *args, **kwargs)
 
     def run(self):
-        " Run tasks. "
-        self._Thread__target(task=self, *self._Thread__args, **self._Thread__kwargs)
-
-        # Wait for result parsing
-        while not self.stopped():
-            time.sleep(.2)
+        """ Run the task.
+        """
+        try:
+            args, kwargs = self._Thread__args, self._Thread__kwargs
+            checking = self._Thread__target(*args, **kwargs)
+            if not self.stop.isSet():
+                RESULTS.put((checking, args, kwargs))
 
-    def stop(self):
-        " Stop task. "
-        self._stop.set()
-
-    def stopped(self):
-        return self._stop.isSet()
-
-
-def stop_queue():
-    " Stop all tasks. "
-    for thread in threading.enumerate():
-        if isinstance(thread, Task):
-            thread.stop()
-            show_message('%s stopped.' % thread.title)
+        except Exception as e:
+            if not self.stop.isSet():
+                RESULTS.put(e)
 
 
-def add_task(target, callback=None, buffer=None, title=None, *args, **kwargs):
+def add_task(target, title=None, *args, **kwargs):
     " Add all tasks. "
 
-    task = Task(buffer, title=title, target=target, callback=callback, args=args, kwargs=kwargs)
+    task = Task(target=target, args=args, kwargs=kwargs)
     task.daemon = True
     task.start()
 
-    show_message('%s started.' % task.title)
+    show_message('{0} started.'.format(title))
 
 
-def check_task():
-    " Check tasks for result. "
+def stop_queue(message=True):
+    """ Stop all tasks.
+    """
+    with RESULTS.mutex:
+        RESULTS.queue.clear()
+
     for thread in threading.enumerate():
         if isinstance(thread, Task):
-            if thread.finished:
-                thread.stop()
-                thread.callback(thread.result, thread.buffer.number)
-            else:
-                show_message('%s %s%%' % (thread.title, thread.done))
+            thread.stop.set()
+            if message:
+                show_message("Task stopped.")
+
+
+def check_task():
+    """ Checking running tasks.
+    """
+    try:
+        result = RESULTS.get(False)
+        assert isinstance(result, tuple)
+    except Empty:
+        return False
+    except AssertionError:
+        return False
+    result, _, kwargs = result
+    callback = kwargs.pop('callback')
+    callback(result, **kwargs)
+
+
+# lint_ignore=W0703
