Add Rotor.run and Rotor.run_async

Author: HashNuke

lib/rotor.ex

@@ -12,7 +12,10 @@ defmodule Rotor do
   defdelegate watch(name, paths, rotor_fn), to: Rotor.GroupServer, as: :add
 
 
+  defdelegate run(name), to: Rotor.GroupServer
+  defdelegate run_async(name), to: Rotor.GroupServer
+
+
   defdelegate remove_group(name),  to: Rotor.GroupServer, as: :remove
   defdelegate stop_watching(name), to: Rotor.GroupServer, as: :remove
-
 end

lib/rotor/file_watcher.ex

@@ -2,7 +2,6 @@ defmodule Rotor.FileWatcher do
   import Rotor.Utils
   use GenServer
 
-
   def start_link(args \\ []) do
     GenServer.start_link(__MODULE__, args)
   end
@@ -18,7 +17,21 @@ defmodule Rotor.FileWatcher do
   end
 
 
+  # This is for synchronous poll
+  def handle_call(:poll, _from, state) do
+    new_state = poll(state)
+    {:reply, :ok, new_state}
+  end
+
+
+  # This is for async poll
   def handle_info(:poll, state) do
+    new_state = poll(state)
+    {:noreply, new_state}
+  end
+
+
+  defp poll(state) do
     group_info = Rotor.group_info(state.name)
     {changed_files, file_index} = case get_in(state, [:file_index]) do
       nil ->
@@ -31,7 +44,7 @@ defmodule Rotor.FileWatcher do
 
     state = run_rotor_function(state, changed_files, file_index)
     schedule_poll(group_info.options.manual, group_info.options.interval)
-    {:noreply, state}
+    state
   end
 
 
@@ -43,7 +56,7 @@ defmodule Rotor.FileWatcher do
   end
 
 
-  defp run_rotor_function(state, [], file_index) do
+  defp run_rotor_function(state, [], _file_index) do
     state
   end
 

lib/rotor/file_watcher_pool.ex

@@ -14,6 +14,9 @@ defmodule Rotor.FileWatcherPool do
 
   def add(group_name, is_manual) do
     watcher_info = %{name: group_name, manual: is_manual}
+
+    # Pass ID to make sure that the process is unique.
+    # This avoids having to handle termination.
     child = worker(Rotor.FileWatcher, [watcher_info], id: unique_id(group_name))
     Supervisor.start_child(__MODULE__, child)
   end

lib/rotor/group_server.ex

@@ -26,25 +26,42 @@ defmodule Rotor.GroupServer do
       {group_info, updated_groups}
     end
 
-    start_file_watcher(name, group_info.options)
+    pid = start_file_watcher(name, group_info.options)
+    Agent.update __MODULE__, fn(groups)->
+      put_in groups, [name, :file_watcher_pid], pid
+    end
     :ok
   end
 
 
+  def remove(name) do
+    Agent.update __MODULE__, fn(groups)->
+      Rotor.FileWatcherPool.remove(name)
+      Map.delete groups, name
+    end
+  end
+
+
+  def run(name) do
+    group_info = Rotor.group_info name
+    GenServer.call group_info.file_watcher_pid, :poll
+  end
+
+
+  def run_async(name) do
+    group_info = Rotor.group_info name
+    send group_info.file_watcher_pid, :poll
+  end
+
+
   defp start_file_watcher(name, options) do
     case Rotor.FileWatcherPool.add(name, options.manual) do
       {:error, {:already_started, _pid}} ->
         Rotor.FileWatcherPool.remove(name)
         start_file_watcher(name, options)
-      {:ok, pid} -> send(pid, :poll)
-    end
-  end
-
-
-  def remove(name) do
-    Agent.update __MODULE__, fn(groups)->
-      Rotor.FileWatcherPool.remove(name)
-      Map.delete groups, name
+      {:ok, pid} ->
+        send(pid, :poll)
+        pid
     end
   end
 

lib/rotor/utils.ex

@@ -1,6 +1,5 @@
 defmodule Rotor.Utils do
 
-
   def update_file_index_timestamps(current_index) do
     reducer = fn({path, file}, {changed_files, index})->
       case File.stat(path) do
@@ -25,12 +24,13 @@ defmodule Rotor.Utils do
   end
 
 
-  def build_file_index([], file_index) do
-    file_index
+  def build_file_index(paths) do
+    build_file_index(paths, HashDict.new)
   end
 
+  def build_file_index([], file_index), do: file_index
 
-  def build_file_index([path | paths], file_index \\ HashDict.new) do
+  def build_file_index([path | paths], file_index) do
     updated_file_index = Enum.reduce Path.wildcard(path), file_index, fn(file_path, index)->
       {:ok, file_info} = File.stat(file_path)
       if file_info.type == :directory || HashDict.has_key?(index, file_path) do

test/rotor_test.exs

@@ -28,8 +28,8 @@ defmodule RotorTest do
 
   test "should watch for changes and run pipeline functions" do
     output_path = "test/samples/outputs/app.js"
+    File.rm output_path
     Rotor.watch :javascripts_pipeline_test, ["test/samples/*.js"], fn(_changed_files, all_files)->
-      IO.inspect "Running callback for javascripts"
       read_files(all_files)
       |> concat
       |> output_to(output_path)
@@ -43,4 +43,59 @@ defmodule RotorTest do
     {:ok, contents} = File.read output_path
     assert Regex.match?(~r/x=1/, contents) && Regex.match?(~r/y=2/, contents)
   end
+
+
+  test "should not watch for changes if group is set to manual" do
+    group_name = :javascripts_pipeline_test
+    output_path = "test/samples/outputs/app.js"
+    File.rm output_path
+
+    Rotor.watch(group_name, ["test/samples/*.js"], fn(_changed_files, all_files)->
+      read_files(all_files)
+      |> concat
+      |> output_to(output_path)
+    end, %{manual: true})
+
+    # Touch the file
+    :ok = :timer.sleep(1000)
+    :ok = File.touch "test/samples/app1.js"
+    :ok = :timer.sleep(2000)
+
+    # Should be an error
+    assert File.read(output_path) == {:error, :enoent}
+
+    Rotor.run(group_name)
+    Rotor.stop_watching(group_name)
+
+    {:ok, contents} = File.read output_path
+    assert Regex.match?(~r/x=1/, contents) && Regex.match?(~r/y=2/, contents)
+  end
+
+
+  test "should not watch for changes if group is set to manual (async)" do
+    group_name = :javascripts_pipeline_test
+    output_path = "test/samples/outputs/app.js"
+    File.rm output_path
+
+    Rotor.watch(group_name, ["test/samples/*.js"], fn(_changed_files, all_files)->
+      read_files(all_files)
+      |> concat
+      |> output_to(output_path)
+    end, %{manual: true})
+
+    # Touch the file
+    :ok = :timer.sleep(1000)
+    :ok = File.touch "test/samples/app1.js"
+    :ok = :timer.sleep(2000)
+
+    # Should be an error
+    assert File.read(output_path) == {:error, :enoent}
+
+    Rotor.run_async(group_name)
+    :ok = :timer.sleep(1000)
+    Rotor.stop_watching(group_name)
+
+    {:ok, contents} = File.read output_path
+    assert Regex.match?(~r/x=1/, contents) && Regex.match?(~r/y=2/, contents)
+  end
 end