Improve thread (#84)

* Refactor thread code into separated file

* Update version

* Clean up readme

Author: zsinx6

README.rst

@@ -52,39 +52,4 @@ Check the `CONTRIBUING.rst <https://github.com/grupy-sanca/dojo-toolkit/blob/mai
 Dependencies
 ------------
 - Python 3
-- `Libnotify <https://developer.gnome.org/libnotify>`_
-
-
-Roadmap
--------
-
-**0.5**
-
-TDB
-
-
-Changelog
----------
-
-**0.4**
-
-- Tests + CI
-- Sound notifications
-- Minor bug fixes
-- Minor improvements
-
-**0.3**
-
-- Major refactor
-- Uses bumpversion
-
-**0.2**
-
-- Project improvements
-- Release to PyPI
-
-**0.1**
-
-- Timer for managing rounds
-- Watch code folder and run doctests on changes
-- Show notifications using Libnotify
+- (Optional) `Libnotify <https://developer.gnome.org/libnotify>`_

dojo_toolkit/code_handler.py

@@ -2,8 +2,6 @@
 
 from watchdog.events import PatternMatchingEventHandler
 
-from dojo_toolkit.notifier import notifier
-
 
 class DojoCodeHandler(PatternMatchingEventHandler):
     """Handles the python file changes"""
@@ -23,10 +21,6 @@ def __init__(self, *args, **kwargs):
     def get_last_test_run_interval(self):
         return time.time() - self.last_test_run_time
 
-    def handle_stopped_round(self):
-        notifier.notify("Round has not been started")
-        print("Press <Enter> to start the round")
-
     def on_modified(self, event):
         """Called when a file in the dojo directory is modified
         runs the doctest and display a notification
@@ -35,8 +29,7 @@ def on_modified(self, event):
         """
 
         if not self.dojo.round_started:
-            return self.handle_stopped_round()
-
+            return
         if self.get_last_test_run_interval() < self.min_test_time_interval:
             return
         self.last_test_run_time = time.time()

dojo_toolkit/dojo.py

@@ -1,83 +1,43 @@
 import sys
-import time
 from threading import Thread
 from unittest import mock
 
-from clint.textui import colored
 from watchdog.observers import Observer
 
+from dojo_toolkit import dojo_thread
 from dojo_toolkit.code_handler import DojoCodeHandler
-from dojo_toolkit.notifier import notifier
 from dojo_toolkit.sound_handler import SoundHandler
 from dojo_toolkit.test_runner import get_test_runner
 from dojo_toolkit.timer import Timer
 
 
 class Dojo:
     ROUND_TIME = 5
-    round_started = False
 
     def __init__(self, code_path, round_time=None, mute=False, test_runner=None, runner="doctest"):
         self.code_path = code_path
         self.round_time = round_time or self.ROUND_TIME
         self.sound_player = mock.Mock() if mute or sys.platform != "linux" else SoundHandler()
         self.info_notified = False
+        self.timer = Timer(self.round_time)
 
         test_runner = get_test_runner(test_runner, runner, self.code_path, self.sound_player)
+        self.controller = dojo_thread.DojoController(self.timer, self.sound_player)
 
-        event_handler = DojoCodeHandler(dojo=self, test_runner=test_runner)
+        event_handler = DojoCodeHandler(dojo=self.controller, test_runner=test_runner)
 
         self.observer = Observer()
         self.observer.schedule(event_handler, self.code_path, recursive=False)
 
-        self.timer = Timer(self.round_time)
-
     def start(self):
         self.observer.start()
         print("\nWatching: {} folder".format(self.code_path))
 
         self.is_running = True
         print("Dojo toolkit started!")
-        self.thread = Thread(target=self.dojo)
+        self.thread = Thread(target=dojo_thread.main, args=(self.controller,))
         self.thread.daemon = True
         self.thread.start()
 
         self.thread.join()
         self.observer.join()
-
-    def stop(self):
-        self.is_running = False
-
-    def await_pilot_exchange(self):
-        print("Awaiting the pilot and co-pilot to enter their positions.")
-        print("Press <Enter> when they are ready")
-        input()
-
-    def round_start(self):
-        self.timer.start()
-        self.sound_player.play_start()
-        self.round_started = True
-        self.info_notified = False
-
-        print("Round started! {} minutes left...".format(self.round_time))
-
-    def round_info(self):
-        if self.timer.ellapsed_time == self.timer.duration - 60 and not self.info_notified:
-            notifier.notify("60 seconds to round finish...")
-            print((getattr(colored, "yellow"))("Round is going to finish in 60 seconds"))
-            self.info_notified = True
-
-    def round_finished(self):
-        notifier.notify("Time Up", timeout=15 * 1000)
-        self.sound_player.play_timeup()
-        self.round_started = False
-        print("Round finished!\n")
-
-    def dojo(self):
-        while self.is_running:
-            self.await_pilot_exchange()
-            self.round_start()
-            while self.timer.is_running:
-                self.round_info()
-                time.sleep(0.8)
-            self.round_finished()

dojo_toolkit/dojo_thread.py

@@ -0,0 +1,51 @@
+import time
+from dataclasses import dataclass
+
+from clint.textui import colored
+
+from dojo_toolkit.notifier import notifier
+from dojo_toolkit.sound_handler import SoundHandler
+from dojo_toolkit.timer import Timer
+
+
+@dataclass
+class DojoController:
+    timer: Timer
+    sound_player: SoundHandler
+    is_running: bool = True
+    round_started: bool = False
+    info_notified: bool = False
+
+    def await_pilot_exchange(self):
+        print("Awaiting the pilot and co-pilot to enter their positions.")
+        print("Press <Enter> when they are ready")
+        input()
+        print("Starting round...")
+
+    def round_start(self):
+        self.timer.start()
+        self.sound_player.play_start()
+        self.round_started = True
+        self.info_notified = False
+
+    def round_info(self):
+        if self.timer.elapsed_time == self.timer.duration - 60 and not self.info_notified:
+            notifier.notify("60 seconds to round finish...")
+            print((getattr(colored, "yellow"))("Round is going to finish in 60 seconds"))
+            self.info_notified = True
+
+    def round_finished(self):
+        notifier.notify("Time Up", timeout=15 * 1000)
+        self.sound_player.play_timeup()
+        self.round_started = False
+        print("Round finished!\n")
+
+
+def main(controller: DojoController):
+    while controller.is_running:
+        controller.await_pilot_exchange()
+        controller.round_start()
+        while controller.timer.is_running:
+            controller.round_info()
+            time.sleep(0.8)
+        controller.round_finished()

dojo_toolkit/timer.py

@@ -6,14 +6,14 @@
 class Timer:
     """
     A timer that runs on a separated thread and "ticks" every second. It
-    keeps track of the ellapsed time.
+    keeps track of the elapsed time.
     """
 
     def __init__(self, duration_in_minutes):
         self.duration = duration_in_minutes * 60
 
     def start(self):
-        self.ellapsed_time = 0
+        self.elapsed_time = 0
 
         self.is_running = True
         self.start_time = time.time()
@@ -22,7 +22,7 @@ def start(self):
         self.thread.start()
 
     def timer(self):
-        while self.ellapsed_time <= self.duration:
-            self.ellapsed_time = floor(time.time() - self.start_time)
+        while self.elapsed_time <= self.duration:
+            self.elapsed_time = floor(time.time() - self.start_time)
             time.sleep(1)
         self.is_running = False

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dojo-toolkit"
-version = "0.7.0a0"
+version = "0.7.0"
 description = "Toolkit for Python Coding Dojos."
 authors = ["grupy-sanca"]
 packages = [{ include = "dojo_toolkit" }]

tests/test_dojo.py

@@ -22,79 +22,3 @@ def test_dojo_start(input, thread, mocked_dojo):
     assert mocked_dojo.thread.start.called
     assert mocked_dojo.thread.join.called
     assert mocked_dojo.observer.join.called
-
-
-@mock.patch("dojo_toolkit.dojo.input")
-def test_dojo_dojo(input, mocked_dojo):
-    mocked_dojo.is_running = True
-    mocked_dojo.timer.is_running = False
-    mocked_dojo.round_finished = mock.Mock(side_effect=KeyboardInterrupt)
-    with pytest.raises(KeyboardInterrupt):
-        mocked_dojo.dojo()
-
-
-@mock.patch("dojo_toolkit.dojo.input")
-def test_dojo_dojo_timer_running(input, mocked_dojo):
-    mocked_dojo.is_running = True
-    mocked_dojo.timer.is_running = True
-
-    def stop_dojo():
-        mocked_dojo.is_running = False
-
-    def stop_timer():
-        mocked_dojo.timer.is_running = False
-
-    mocked_dojo.round_info = mock.Mock(side_effect=stop_timer)
-    mocked_dojo.round_finished = mock.Mock(side_effect=stop_dojo)
-    mocked_dojo.dojo()
-
-
-def test_dojo_dojo_stopped(mocked_dojo):
-    mocked_dojo.is_running = False
-    mocked_dojo.dojo()
-
-
-@mock.patch("dojo_toolkit.dojo.input")
-def test_dojo_await_pilot_exchange(six_input, mocked_dojo):
-    mocked_dojo.await_pilot_exchange()
-    assert six_input.called
-
-
-def test_dojo_round_start(mocked_dojo):
-    assert mocked_dojo.round_started is False
-
-    mocked_dojo.round_start()
-
-    assert mocked_dojo.timer.start.called
-    assert mocked_dojo.sound_player.play_start.called
-    assert mocked_dojo.round_started is True
-
-
-@mock.patch("dojo_toolkit.dojo.notifier")
-def test_dojo_round_info_without_notification(notifier, mocked_dojo):
-    mocked_dojo.round_info()
-    assert not notifier.notify.called
-
-
-@mock.patch("dojo_toolkit.dojo.notifier")
-def test_dojo_round_info_with_notification(notifier, mocked_dojo):
-    mocked_dojo.timer.duration = 120
-    mocked_dojo.timer.ellapsed_time = 60
-    mocked_dojo.round_info()
-    assert notifier.notify.called
-
-
-@mock.patch("dojo_toolkit.dojo.notifier")
-def test_dojo_round_finished(notifier, mocked_dojo):
-    mocked_dojo.round_started = True
-
-    mocked_dojo.round_finished()
-
-    assert notifier.notify.called
-    assert mocked_dojo.sound_player.play_timeup.called
-    assert mocked_dojo.round_started is False
-
-
-def test_dojo_stop(mocked_dojo):
-    mocked_dojo.stop()
-    assert mocked_dojo.is_running is False