renames and rearrangements: get rid of CSys, move core stuff to Core

lib/core/core.ex

@@ -1,10 +1,10 @@
-defmodule Scopes.CSys do
+defmodule Scopes.Core do
   require Logger
-  require Scopes.Util
+  require Scopes.Core.Util
 
   alias Scopes.Core.Actor
-  alias Scopes.Shape
-  alias Scopes.Util
+  alias Scopes.Core.Shape
+  alias Scopes.Core.Util
 
   def neuron(scope) do
     #Logger.info(Util.show [scope])

lib/core/environ.ex

@@ -1,7 +1,7 @@
-defmodule Scopes.CSys.Environ do
+defmodule Scopes.Core.Environ do
 
-  alias Scopes.CSys
-  alias Scopes.Shape
+  alias Scopes.Core
+  alias Scopes.Core.Shape
 
   defmodule State do
     defstruct [cells: %{}, init_seq: []]
@@ -9,10 +9,10 @@ defmodule Scopes.CSys.Environ do
 
   def setup({state, proc}, init_seq, proc_env \\ &proc_env/2) do
     env_scope = {%State{init_seq: init_seq}, proc_env, [], self()}
-    env = CSys.neuron(env_scope)
+    env = Core.neuron(env_scope)
     msg = Shape.create([:csys, :zero], data: %{addr: [:csys, :c00, {0, 0}]})
     proc = {state, proc, [], env}
-    CSys.create(msg, proc)
+    Core.create(msg, proc)
     env
   end
 
@@ -37,9 +37,8 @@ defmodule Scopes.CSys.Environ do
     end
     {step, seq} = List.pop_at(state.init_seq, 0)
     state1 = %State{cells: cells, init_seq: seq}
-    CSys.update({state1, proc, syns, env})
+    Core.update({state1, proc, syns, env})
     if step do
-      #Process.sleep(1)
       step.(state1)
     end
   end
@@ -52,7 +51,7 @@ defmodule Scopes.CSys.Environ do
 
   def send_message(state, addr, head, data) do
     cell = get_cell(state, addr)
-    CSys.send_message(cell, head, data)
+    Core.send_message(cell, head, data)
   end
 
   def connect(state, addr, target, op \\ []) do
@@ -63,7 +62,7 @@ defmodule Scopes.CSys.Environ do
   # delegating tasks to env
 
   def delegate(env, func) do
-    CSys.send_message(env, {:exec, func})
+    Core.send_message(env, {:exec, func})
   end
 
   def forward_value(env, addr, value) do

lib/core/program.ex

@@ -1,11 +1,11 @@
-defmodule Scopes.CSys.Program do
+defmodule Scopes.Core.Program do
   require Logger
-  require Scopes.Util
+  require Scopes.Core.Util
 
-  alias Scopes.CSys
-  alias Scopes.CSys.Environ
-  alias Scopes.Shape
-  alias Scopes.Util
+  alias Scopes.Core
+  alias Scopes.Core.Environ
+  alias Scopes.Core.Shape
+  alias Scopes.Core.Util
 
   defmodule State do
     defstruct [:value, :count, :stage, :prog]
@@ -59,11 +59,11 @@ defmodule Scopes.CSys.Program do
       case Shape.head(msg) do
         [:csys, :data | _rest] -> process_basic(msg, scope, args)
         #[:csys, :trigger | _rest] -> process_trigger(msg, scope)
-        [:csys, :connect | _rest] -> CSys.connect(msg, scope)
+        [:csys, :connect | _rest] -> Core.connect(msg, scope)
         [:csys, :create, :succ | _rest] -> create_succ(msg, scope)
         [:csys, :create, :pred | _rest] -> create_pred(msg, scope)
         #[:csys, :next | _rest] -> next(msg, scope)
-        _ -> CSys.forward(msg, scope) || CSys.notify(msg, scope)
+        _ -> Core.forward(msg, scope) || Core.notify(msg, scope)
       end
     end
   end
@@ -75,32 +75,32 @@ defmodule Scopes.CSys.Program do
     bias = args[:bias] || 0
     limit = args[:limit]
     data = Shape.data(msg)
-    state = CSys.state(scope)
+    state = Core.state(scope)
     Logger.debug(Util.show [data, state.value, threshold])
     value_n = state.value + data.value
     if value_n >= threshold do
       value_out = limit && rem(value_n - 1, limit) + limit || value_n
       value_next = limit && max(value_n - limit, bias) || bias
       msg = Shape.create(Shape.head(msg), data: %{data | value: value_out})
-      CSys.forward(msg, scope) || CSys.notify(msg, scope)
+      Core.forward(msg, scope) || Core.notify(msg, scope)
       state_n = %{state | value: value_next}
-      CSys.update(put_elem(scope, 0, state_n))
+      Core.update(put_elem(scope, 0, state_n))
     else
       state_n = %{state | value: value_n}
-      CSys.update(put_elem(scope, 0, state_n))
+      Core.update(put_elem(scope, 0, state_n))
     end
   end
 
   def create_succ(msg, scope) do
-    new = CSys.create(msg, restart(scope))
+    new = Core.create(msg, restart(scope))
     data = Shape.data(msg)
-    CSys.send_message(self(), ~w(csys connect)a, Map.put(data, :target, new))
+    Core.send_message(self(), ~w(csys connect)a, Map.put(data, :target, new))
   end
 
   def create_pred(msg, scope) do
-    new = CSys.create(msg, restart(scope))
+    new = Core.create(msg, restart(scope))
     data = Shape.data(msg)
-    CSys.send_message(new, ~w(csys connect)a, Map.put(data, :target, self()))
+    Core.send_message(new, ~w(csys connect)a, Map.put(data, :target, self()))
   end
 
   # synapse operations
@@ -131,11 +131,11 @@ defmodule Scopes.CSys.Program do
     [
       fn state -> 
         Environ.send_message(state, zero, ~w(csys create pred)a, 
-         %{op: [CSys.data_only(), negate()], addr: one})
+         %{op: [Core.data_only(), negate()], addr: one})
      end,
      fn state -> 
        Environ.send_message(state, one, ~w(csys create succ)a, 
-         %{op: CSys.data_only(), addr: two}) 
+         %{op: Core.data_only(), addr: two}) 
      end,
       fn state -> 
         Environ.send_message(state, two, ~w(csys create pred)a, %{addr: three}) 

lib/core/shape.ex

@@ -1,4 +1,4 @@
-defmodule Scopes.Shape do
+defmodule Scopes.Core.Shape do
   def create(head, info \\ []) do
     {head, info}
   end

lib/core/util.ex

@@ -1,4 +1,4 @@
-defmodule Scopes.Util do
+defmodule Scopes.Core.Util do
   defmacro show(fields) do
     names = for f <- fields do Macro.to_string(f) end
     quote bind_quoted: [names: names, fields: fields] do

test/core/actor_test.exs

@@ -1,4 +1,4 @@
-defmodule Scopes.CoreTest do
+defmodule Scopes.CoreActorTest do
   use ExUnit.Case, async: true
   alias Scopes.Core.Actor
 

test/core/core_test.exs

@@ -1,11 +1,10 @@
-defmodule Scopes.CSysTest do
+defmodule Scopes.CoreTest do
   use ExUnit.Case, async: false
   @moduletag timeout: 5000
 
-  #alias Scopes.CSys
-  alias Scopes.CSys.Environ
-  alias Scopes.CSys.Program
-  alias Scopes.Shape
+  alias Scopes.Core.Environ
+  alias Scopes.Core.Program
+  alias Scopes.Core.Shape
 
   def receive_select(head) do
     assert_receive {^head, info}, 100
@@ -16,7 +15,7 @@ defmodule Scopes.CSysTest do
     Shape.data(receive_select(head))
   end
 
-  describe "basic-program:" do
+  describe "core-basic:" do
     test "minimal-b1" do
       env = Environ.setup(Program.prepare_basic(), Program.init_seq_b1())
       Process.sleep(50)

test/core/shape_test.exs

@@ -1,7 +1,7 @@
-defmodule Scopes.ShapeTest do
+defmodule Scopes.CoreShapeTest do
   use ExUnit.Case, async: true
 
-  alias Scopes.Shape
+  alias Scopes.Core.Shape
 
   describe "shape:" do
     test "basic" do

test/core/util_test.exs

@@ -1,8 +1,8 @@
-defmodule Scopes.UtilTest do
+defmodule Scopes.CoreUtilTest do
   use ExUnit.Case, async: true
 
-  alias Scopes.Util
-  require Scopes.Util
+  alias Scopes.Core.Util
+  require Scopes.Core.Util
 
   describe "info:" do
     test "fields" do