style: apply runic to src, docs

Author: ReubenJ

.pre-commit-config.yaml

@@ -44,7 +44,7 @@ repos:
       rev: v1.38.0
       hooks:
           - id: yamllint
-    - repo: https://github.com/domluna/JuliaFormatter.jl
-      rev: v2.3.0
+    - repo: https://github.com/fredrikekre/runic-pre-commit
+      rev: v2.0.1
       hooks:
-          - id: julia-formatter
+          - id: runic

docs/make.jl

@@ -15,7 +15,7 @@ DocMeta.setdocmeta!(
 const page_rename = Dict("developer.md" => "Developer docs") # Without the numbers
 const numbered_pages = [
     file for file in readdir(joinpath(@__DIR__, "src")) if
-    file != "index.md" && splitext(file)[2] == ".md"
+        file != "index.md" && splitext(file)[2] == ".md"
 ]
 
 makedocs(;

src/gds_interface.jl

@@ -3,15 +3,15 @@ import MetaGraphsNext: labels
 import Compat: @compat
 
 @compat public ScheduleStyle,
-Asynchronous,
-Synchronous,
-GraphDynamicalSystem,
-GDS,
-get_n_entities,
-get_schedule,
-get_graph,
-get_domain,
-get_fn
+    Asynchronous,
+    Synchronous,
+    GraphDynamicalSystem,
+    GDS,
+    get_n_entities,
+    get_schedule,
+    get_graph,
+    get_domain,
+    get_fn
 
 abstract type ScheduleStyle end
 struct Asynchronous <: ScheduleStyle end
@@ -22,15 +22,15 @@ struct Synchronous <: ScheduleStyle end
 # include the ranges of each of the entities. The state of the system is just
 # the current value of each of the entities
 
-abstract type GraphDynamicalSystem{N,S} <: DSB.DiscreteTimeDynamicalSystem end
+abstract type GraphDynamicalSystem{N, S} <: DSB.DiscreteTimeDynamicalSystem end
 const GDS = GraphDynamicalSystem
 
 """
     $(TYPEDSIGNATURES)
 
 Get the number of entities `N` in the GDS.
 """
-function get_n_entities(::GDS{N,S}) where {N,S}
+function get_n_entities(::GDS{N, S}) where {N, S}
     return N
 end
 
@@ -39,7 +39,7 @@ end
 
 Get the schedule for the GDS.
 """
-function get_schedule(::GDS{N,S}) where {N,S}
+function get_schedule(::GDS{N, S}) where {N, S}
     return S
 end
 

src/qualitative_networks.jl

@@ -15,8 +15,8 @@ import Compat: @compat
 A graph dynamical system with a finite domain. State values of each entity are
 limited to change by at most 1 per time step.
 """
-struct QualitativeNetwork{N_Entities,Schedule,Graph<:MG.MetaGraph} <:
-       GraphDynamicalSystem{N_Entities,Schedule}
+struct QualitativeNetwork{N_Entities, Schedule, Graph <: MG.MetaGraph} <:
+    GraphDynamicalSystem{N_Entities, Schedule}
     graph::Graph
 end
 
@@ -34,7 +34,7 @@ DSB.current_time(::QualitativeNetwork) = 0
 DSB.reinit!(qn::QN, state::AbstractVector) = DSB.set_state!(qn, Int.(state))
 
 
-mutable struct QNEntity{F,S,D} <: AbstractEntity
+mutable struct QNEntity{F, S, D} <: AbstractEntity
     fn::F
     state::S
     domain::D
@@ -49,16 +49,16 @@ function DSB.set_state!(qne::QNEntity, s)
             "New state value for entity must be within its domain (domain: $domain, new state: $s)",
         )
     end
-    qne.state = s
+    return qne.state = s
 end
 get_domain(qne::QNEntity) = qne.domain
 
-function QualitativeNetwork(graph::G) where {G<:Graphs.AbstractGraph}
-    QualitativeNetwork{Graphs.nv(graph),Synchronous(),G}(graph)
+function QualitativeNetwork(graph::G) where {G <: Graphs.AbstractGraph}
+    return QualitativeNetwork{Graphs.nv(graph), Synchronous(), G}(graph)
 end
 
 function QualitativeNetwork(update_functions::AbstractDict, domains)
-    QualitativeNetwork{Graphs.SimpleDiGraph}(update_functions, domains)
+    return QualitativeNetwork{Graphs.SimpleDiGraph}(update_functions, domains)
 end
 
 """
@@ -72,49 +72,49 @@ The entity names (`E` in the signature) can be anything, while the functions (`F
 - implement the `TermInterface.jl` interface. Any terminal nodes in the functions must be numerical constants or reference an entity.
 """
 function QualitativeNetwork{GraphType}(
-    update_functions::AbstractDict{E,F},
-    domains,
-)::QualitativeNetwork where {E,F,GraphType<:Graphs.AbstractGraph}
+        update_functions::AbstractDict{E, F},
+        domains,
+    )::QualitativeNetwork where {E, F, GraphType <: Graphs.AbstractGraph}
     entity_keys = collect(keys(update_functions))
     entity_fns = getindex.((update_functions,), entity_keys)
     entity_domains = getindex.((domains,), entity_keys)
     get_arguments_or_empty = x -> TI.isexpr(x) ? (x, TI.arguments(x)) : (x, ())
     collect_arguments =
         x ->
-            AT.treemap(get_arguments_or_empty, x) |>
-            AT.Leaves .|>
-            AT.nodevalue |>
-            filter(in(entity_keys))
+    AT.treemap(get_arguments_or_empty, x) |>
+        AT.Leaves .|>
+        AT.nodevalue |>
+        filter(in(entity_keys))
 
     referenced_entities = union.(collect_arguments.(entity_fns))
     referenced_indices =
         map(ref_for_e -> findfirst.(.==(ref_for_e), (entity_keys,)), referenced_entities)
     edges =
         Iterators.flatten(
-            map(((j, idxs),) -> tuple.(idxs, (j,)), enumerate(referenced_indices)),
-        ) |> collect
+        map(((j, idxs),) -> tuple.(idxs, (j,)), enumerate(referenced_indices)),
+    ) |> collect
     graph = GraphType()
     Graphs.add_vertices!(graph, length(entity_keys))
     Graphs.add_edge!.((graph,), Graphs.Edge.(edges))
-    vertices_description = Pair{E,QNEntity}[
+    vertices_description = Pair{E, QNEntity}[
         (e => QNEntity(fn, 0, d)) for
-        (e, fn, d) in zip(entity_keys, entity_fns, entity_domains)
+            (e, fn, d) in zip(entity_keys, entity_fns, entity_domains)
     ]
-    edges_description = Pair{Tuple{E,E},Nothing}[
+    edges_description = Pair{Tuple{E, E}, Nothing}[
         (entity_keys[s], entity_keys[d]) => nothing for (s, d) in edges
     ]
     return QualitativeNetwork(
         MG.MetaGraph(graph, vertices_description, edges_description, nothing),
     )
 end
 
-function SciMLBase.step!(qn::QualitativeNetwork{N,S}) where {N,S}
-    SciMLBase.step!(S, qn)
+function SciMLBase.step!(qn::QualitativeNetwork{N, S}) where {N, S}
+    return SciMLBase.step!(S, qn)
 end
 SciMLBase.step!(qn::QN, n::Int, _...) = foreach(_ -> SciMLBase.step!(qn), 1:n)
 
 function limit_change(next, prev, lower, upper)
-    if next > prev
+    return if next > prev
         min(upper, prev + 1)
     elseif next < prev
         max(lower, prev - 1)
@@ -124,18 +124,18 @@ function limit_change(next, prev, lower, upper)
 end
 
 function DSB.set_state!(
-    qn::QN{N,S,M},
-    new_state::Int,
-    entity::L,
-) where {N,S,I,G,L,M<:MG.MetaGraph{I,G,L}}
+        qn::QN{N, S, M},
+        new_state::Int,
+        entity::L,
+    ) where {N, S, I, G, L, M <: MG.MetaGraph{I, G, L}}
     g = get_graph(qn)
-    DSB.set_state!(g[entity], new_state)
+    return DSB.set_state!(g[entity], new_state)
 end
 
 function DSB.set_state!(qn::QN, new_state::AbstractVector)
     g = get_graph(qn)
 
-    DSB.set_state!.((qn,), new_state, MG.labels(g))
+    return DSB.set_state!.((qn,), new_state, MG.labels(g))
 end
 
 function SciMLBase.step!(::Synchronous, qn::QualitativeNetwork)
@@ -155,7 +155,7 @@ function SciMLBase.step!(::Synchronous, qn::QualitativeNetwork)
 end
 
 function interpret(fn, state)
-    MLStyle.@match fn begin
+    return MLStyle.@match fn begin
         ::Int => fn
         ::Symbol => state[fn]
         :($a + $b) => interpret(a, state) + interpret(b, state)