Update Dependencies and create more tests.

.github/workflows/ci-linux.yml

@@ -17,9 +17,9 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-      - uses: swift-actions/setup-swift@v1
+      - uses: slashmo/install-swift@v0.4.0
         with:
-          swift-version: ${{ matrix.swift }}
+          version: ${{ matrix.swift }}
 
       - name: Setup SSH Key
         run: | 

.github/workflows/ci-macOS.yml

@@ -10,7 +10,7 @@ jobs:
   build_macos:
     strategy:
       matrix:
-        os: [macos-13]
+        os: [macos-14]
         build_mode: ["debug", "release"]
     name: Swift ${{ matrix.build_mode }} CI for ${{ matrix.os }}
     runs-on: ${{ matrix.os }}

.github/workflows/cov.yml

@@ -14,9 +14,9 @@ jobs:
     runs-on: ubuntu-20.04
 
     steps:
-      - uses: swift-actions/setup-swift@v1
+      - uses: slashmo/install-swift@v0.4.0
         with:
-            swift-version: "5.9"
+          version: "5.9"
 
       - name: Setup SSH Key
         run: | 

.github/workflows/docs.yml

@@ -10,9 +10,9 @@ jobs:
     runs-on: ubuntu-20.04
 
     steps:
-      - uses: swift-actions/setup-swift@v1
+      - uses: slashmo/install-swift@v0.4.0
         with:
-            swift-version: "5.9"
+          version: "5.9"
 
       - name: Setup SSH Key
         run: | 

Package.swift

@@ -20,10 +20,10 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
-        .package(url: "https://github.com/mipalgu/VHDLMachines", from: "2.1.0"),
+        .package(url: "https://github.com/mipalgu/VHDLMachines", from: "3.1.0"),
         .package(url: "https://github.com/mipalgu/VHDLParsing", from: "2.4.0"),
         .package(url: "https://github.com/apple/swift-argument-parser", from: "1.3.0"),
-        .package(url: "https://github.com/mipalgu/VHDLKripkeStructureGenerator.git", from: "0.2.0"),
+        .package(url: "https://github.com/mipalgu/VHDLKripkeStructureGenerator.git", from: "0.2.1"),
         .package(url: "https://github.com/CPSLabGU/SwiftUtils.git", from: "0.1.0")
     ],
     targets: [
@@ -63,12 +63,19 @@ let package = Package(
                 .product(name: "VHDLParsing", package: "VHDLParsing"),
                 .product(name: "ArgumentParser", package: "swift-argument-parser"),
                 .product(name: "VHDLKripkeStructureGenerator", package: "VHDLKripkeStructureGenerator"),
-                .product(name: "SwiftUtils", package: "SwiftUtils")
+                .product(name: "SwiftUtils", package: "SwiftUtils"),
+                "TestHelpers"
             ]
         ),
         .testTarget(
-            name: "VHDLMachineTransformationsTests",
+            name: "TestHelpers",
             dependencies: ["VHDLMachineTransformations", "VHDLParsing", "VHDLMachines", "JavascriptModel"]
+        ),
+        .testTarget(
+            name: "VHDLMachineTransformationsTests",
+            dependencies: [
+                "VHDLMachineTransformations", "VHDLParsing", "VHDLMachines", "JavascriptModel", "TestHelpers"
+            ]
         )
     ]
 )

Sources/JavascriptModel/ArrangementModel.swift

@@ -74,6 +74,9 @@ public struct ArrangementModel: Equatable, Hashable, Codable, Sendable {
     /// but cannot affect the outside world.
     public var globalVariables: String
 
+    /// The mappings between external and global variables.
+    public var globalMappings: [VariableMapping]
+
     /// Initialise the arrangement from it's stored properties.
     /// - Parameters:
     ///   - clocks: The clocks used in this arrangement.
@@ -86,12 +89,14 @@ public struct ArrangementModel: Equatable, Hashable, Codable, Sendable {
         clocks: [ClockModel],
         externalVariables: String,
         machines: [MachineReference],
-        globalVariables: String
+        globalVariables: String,
+        globalMappings: [VariableMapping] = []
     ) {
         self.clocks = clocks
         self.externalVariables = externalVariables
         self.machines = machines
         self.globalVariables = globalVariables
+        self.globalMappings = globalMappings
     }
 
 }

Sources/MachineGenerator/Generate.swift

@@ -142,9 +142,12 @@ struct Generate: ParsableCommand {
         try createModel()
     }
 
+    /// Create an `Arrangement` from the model.
     func createArrangement() throws {
         let model = try decoder.decode(ArrangementModel.self, from: model)
-        guard let arrangement = Arrangement(model: model) else {
+        guard let arrangement = Arrangement(
+            model: model, basePath: self.pathURL.deletingLastPathComponent()
+        ) else {
             throw GenerationError.invalidGeneration(message: "Cannot create valid arrangement from model.")
         }
         let data = try encoder.encode(arrangement)

Sources/MachineGenerator/LLFSMGenerate.swift

@@ -64,7 +64,7 @@ struct LLFSMGenerate: ParsableCommand {
     static var configuration = CommandConfiguration(
         commandName: "llfsmgenerate",
         abstract: "A utility for performing operations on LLFSM formats.",
-        version: "1.3.1",
+        version: "1.4.0",
         subcommands: [Generate.self, VHDLGenerator.self, CleanCommand.self, InstallCommand.self]
     )
 

Sources/MachineGenerator/VHDLGenerator.swift

@@ -89,17 +89,21 @@ struct VHDLGenerator: ParsableCommand {
         try self.createMachine(sourcePath: options.pathURL, destinationPath: buildFolder)
     }
 
+    // swiftlint:disable function_body_length
+
+    /// Create an arrangement.
+    @inlinable
     func createArrangement() throws {
-        let decoder = JSONDecoder()
-        let modelData = try Data(
-            contentsOf: options.pathURL.appendingPathComponent("model.json", isDirectory: false)
-        )
-        let model = try decoder.decode(ArrangementModel.self, from: modelData)
         let nameRaw = options.pathURL.lastPathComponent.dropLast(".arrangement".count)
             .trimmingCharacters(in: .whitespacesAndNewlines)
         guard !nameRaw.isEmpty, let name = VariableName(rawValue: nameRaw) else {
             throw GenerationError.invalidFormat(message: "The arrangement is not named correctly!")
         }
+        let decoder = JSONDecoder()
+        let modelData = try Data(
+            contentsOf: options.pathURL.appendingPathComponent("model.json", isDirectory: false)
+        )
+        let model = try decoder.decode(ArrangementModel.self, from: modelData)
         let arrangementFile = options.pathURL.appendingPathComponent("arrangement.json", isDirectory: false)
         let data = try Data(contentsOf: arrangementFile)
         let arrangement = try decoder.decode(Arrangement.self, from: data)
@@ -155,6 +159,13 @@ struct VHDLGenerator: ParsableCommand {
         try vhdlFile.write(to: destination, options: .atomic)
     }
 
+    // swiftlint:enable function_body_length
+
+    /// Create the VHDL for a machine.
+    /// - Parameters:
+    ///   - sourcePath: The path to the machine to generate.
+    ///   - destinationPath: The folder to store the VHDL generated files.
+    @inlinable
     func createMachine(sourcePath: URL, destinationPath: URL) throws {
         let path = sourcePath.appendingPathComponent("machine.json", isDirectory: false)
         let data = try Data(contentsOf: path)

Sources/VHDLMachineTransformations/Arrangement+modelInit.swift

@@ -58,39 +58,27 @@ import JavascriptModel
 import VHDLMachines
 import VHDLParsing
 
+/// Add conversion initialiser between ``ArrangementModel`` and `Arrangement`.
 extension Arrangement {
 
-    public init?(model: ArrangementModel) {
-        let decoder = JSONDecoder()
-        let machineTuples: [(VariableName, MachineMapping)] = model.machines
-            .compactMap { (reference: MachineReference) -> (VariableName, MachineMapping)? in
-                let url = URL(fileURLWithPath: reference.path, isDirectory: true)
-                guard
-                    let name = VariableName(rawValue: reference.name),
-                    let data = try? Data(
-                        contentsOf: url.appendingPathComponent("model.json", isDirectory: false)
-                    ),
-                    let machineModel = try? decoder.decode(MachineModel.self, from: data),
-                    let machine = Machine(model: machineModel)
-                else {
-                    return nil
-                }
-                let mappings: [VHDLMachines.VariableMapping] = reference.mappings.compactMap {
-                    guard
-                        let source = VariableName(rawValue: $0.source),
-                        let destination = VariableName(rawValue: $0.destination)
-                    else {
-                        return nil
-                    }
-                    return VHDLMachines.VariableMapping(source: source, destination: destination)
-                }
+    /// Create an `Arrangement` from its javascript representation.
+    /// - Parameter model: The javascript model to convert.
+    /// - Parameter basePath: The path of the directory containing the arrangement folder.
+    @inlinable
+    public init?(model: ArrangementModel, basePath: URL? = nil) {
+        let keyNames = model.machines.map(\.name)
+        guard keyNames.count == Set(keyNames).count else {
+            return nil
+        }
+        let machineTuples: [(MachineInstance, MachineMapping)] = model.machines
+            .compactMap { (reference: MachineReference) -> (MachineInstance, MachineMapping)? in
                 guard
-                    mappings.count == reference.mappings.count,
-                    let mapping = MachineMapping(machine: machine, with: mappings)
+                    let instance = MachineInstance(reference: reference),
+                    let mapping = MachineMapping(reference: reference, basePath: basePath)
                 else {
                     return nil
                 }
-                return (name, mapping)
+                return (instance, mapping)
             }
         guard
             machineTuples.count == model.machines.count,
@@ -102,32 +90,97 @@ extension Arrangement {
         let externalsRaw = model.externalVariables.components(separatedBy: ";")
             .filter { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
         let externalSignals = externalsRaw.compactMap { PortSignal(rawValue: $0 + ";") }
-        guard externalSignals.count == externalsRaw.count else {
-            return nil
-        }
         let signalsRaw = model.globalVariables.components(separatedBy: ";")
             .filter { !$0.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }
         let localSignals = signalsRaw.compactMap { LocalSignal(rawValue: $0 + ";") }
-        guard localSignals.count == signalsRaw.count else {
-            return nil
-        }
         let clocks = model.clocks.compactMap { Clock(model: $0) }
-        guard clocks.count == model.clocks.count else {
-            return nil
-        }
         let clockNames = clocks.map(\.name)
         let signalNames = localSignals.map(\.name) + externalSignals.map(\.name)
-        let machineNames: [VariableName] = Array(machines.keys)
-        let allNames = clockNames + signalNames + machineNames
-        guard Set(allNames).count == allNames.count else {
+        let allNames = clockNames + signalNames
+        let globalMappings = model.globalMappings.compactMap {
+            VHDLMachines.VariableMapping(mapping: $0)
+        }
+        guard
+            externalSignals.count == externalsRaw.count,
+            localSignals.count == signalsRaw.count,
+            clocks.count == model.clocks.count,
+            globalMappings.count == model.globalMappings.count,
+            Set(allNames).count == allNames.count
+        else {
             return nil
         }
         self.init(
-            machines: machines,
+            mappings: machines,
             externalSignals: externalSignals,
             signals: localSignals,
-            clocks: clocks
+            clocks: clocks,
+            globalMappings: globalMappings
         )
     }
 
 }
+
+/// Add init from javascript model.
+extension MachineInstance {
+
+    /// Create a `MachineInstace` from its javascript model.
+    /// - Parameter reference: The ``MachineReferece`` js model to convert.
+    @inlinable
+    init?(reference: MachineReference) {
+        let url = URL(fileURLWithPath: reference.path, isDirectory: true)
+        let nameRaw = url.lastPathComponent
+        guard
+            nameRaw.hasSuffix(".machine"),
+            let name = VariableName(rawValue: reference.name),
+            let type = VariableName(rawValue: String(nameRaw.dropLast(8)))
+        else {
+            return nil
+        }
+        self.init(name: name, type: type)
+    }
+
+}
+
+/// Add init from js model.
+extension MachineMapping {
+
+    /// Create a `MachineMapping` from its javascript model.
+    /// - Parameter reference: The ``MachineReferece`` js model to convert.
+    /// - Parameter basePath: The path of the directory containing the arrangement folder.
+    @inlinable
+    init?(reference: MachineReference, basePath: URL? = nil) {
+        let url = URL(fileURLWithPath: reference.path, isDirectory: true, relativeTo: basePath)
+            .appendingPathComponent("model.json", isDirectory: false)
+        let mappings: [VHDLMachines.VariableMapping] = reference.mappings.compactMap {
+            VHDLMachines.VariableMapping(mapping: $0)
+        }
+        guard
+            mappings.count == reference.mappings.count,
+            let data = try? Data(contentsOf: url),
+            let machineModel = try? JSONDecoder().decode(MachineModel.self, from: data),
+            let machine = Machine(model: machineModel)
+        else {
+            return nil
+        }
+        self.init(machine: machine, with: mappings)
+    }
+
+}
+
+/// Add init from js model.
+extension VHDLMachines.VariableMapping {
+
+    /// Create a `VariableMapping` from its javascript model.
+    /// - Parameter mapping: The ``VariableMapping`` js model to convert.
+    @inlinable
+    init?(mapping: JavascriptModel.VariableMapping) {
+        guard
+            let source = VariableName(rawValue: mapping.source),
+            let destination = VariableName(rawValue: mapping.destination)
+        else {
+            return nil
+        }
+        self.init(source: source, destination: destination)
+    }
+
+}