Merge branch 'master' into more-linting-fixes

Author: TGCrystal

linting/.core.cjs

@@ -59,4 +59,4 @@ module.exports = {
         "arrow-spacing": "error",
         "eol-last": "error",
     },
-}
+}

linting/.custom.cjs

@@ -5,4 +5,4 @@ module.exports = {
     "rules": {
         "opencircuits/object-curly-spacing": ["error", "always"],
     },
-}
+}

linting/.deprecation.cjs

@@ -5,4 +5,4 @@ module.exports = {
     "rules": {
         "deprecation/deprecation": "warn",
     }
-}
+}

linting/.imports.cjs

@@ -190,4 +190,4 @@ module.exports = {
             }
         },
     },
-}
+}

linting/.jestRules.cjs

@@ -34,4 +34,4 @@ module.exports = {
 
         "jest-formatting/padding-around-test-blocks": "off",
     },
-}
+}

linting/.jsdoc.cjs

@@ -41,4 +41,4 @@ module.exports = {
         "jsdoc/tag-lines": ["error", "never"],
         "jsdoc/valid-types": "error",
     },
-}
+}

linting/.jsxa11y.cjs

@@ -99,4 +99,4 @@ module.exports = {
         "jsx-a11y/scope": "warn",
         "jsx-a11y/tabindex-no-positive": "warn",
     },
-}
+}

linting/.react.cjs

@@ -136,4 +136,4 @@ module.exports = {
             "version": "detect",
         },
     },
-}
+}

linting/.sonarjs.cjs

@@ -18,4 +18,4 @@ module.exports = {
         "sonarjs/cognitive-complexity": "off",
         "sonarjs/no-duplicate-string": "off",
     },
-}
+}

linting/.ts.cjs

@@ -194,4 +194,4 @@ module.exports = {
             "asyncArrow": "always"
         }],
     },
-}
+}

linting/.unicorn.cjs

@@ -52,4 +52,4 @@ module.exports = {
         "unicorn/prevent-abbreviations": "off",
         "unicorn/no-array-callback-reference": "off",
     },
-}
+}

scripts/webpack/index.ts

@@ -71,7 +71,7 @@ export default async (dir: string, project: string, mode: "development" | "produ
                     const privateTest = /^10\.|^172\.(1[6-9]|2\d|3[01])\.|^192\.168\./;
                     // Check if private
                     if (privateTest.test(ip))
-                        return formatURL(protocol, hostname, chalk.bold(port), pathname);
+                        return formatURL(protocol, ip, chalk.bold(port), pathname);
                 }
             } catch {
                 // Ignore, just defer to localhost

src/app/digital/actions/addition/BusActionFactory.ts

@@ -2,16 +2,66 @@ import {V} from "Vector";
 
 import {Transform} from "math/Transform";
 
+import {GetAllPorts} from "core/utils/ComponentUtils";
+
 import {GroupAction} from "core/actions/GroupAction";
 
 import {ConnectionAction} from "core/actions/addition/ConnectionAction";
 
-import {Component} from "core/models";
+import {Component, Port} from "core/models";
 
 import {InputPort}  from "digital/models/ports/InputPort";
 import {OutputPort} from "digital/models/ports/OutputPort";
 
 
+/**
+ * For use in component bussing (#1056):
+ * Gathers all the ports of the given components that should be bus'd together.
+ *
+ * @param components The component to get the ports of.
+ * @returns            A tuple of the input and output ports to bus.
+ */
+export function GetComponentBusPorts(components: Component[]): [InputPort[], OutputPort[]] {
+    const EmptyInputPorts  = (p: Port): p is InputPort  => (p instanceof  InputPort && p.getWires().length === 0);
+    const EmptyOutputPorts = (p: Port): p is OutputPort => (p instanceof OutputPort && p.getWires().length === 0);
+
+    // Filter out components that don't have exclusively available input or output ports
+    //  these are "ambiguous" components since we might need to bus to their inputs or outputs
+    const ambiComps = components.filter((s) => (
+        s.getPorts().some(EmptyInputPorts) === s.getPorts().some(EmptyOutputPorts)
+    // Then filter out ones that have no available ports
+    )).filter((c) => !(c.getPorts().every((p) => (p.getWires().length > 0))));
+
+    // Output components are components where there are no empty input ports => there are only output ports
+    const outputComps = components.filter((c) => (!c.getPorts().some(EmptyInputPorts)));
+    // Input components are components where there are no empty output ports => there are only input ports
+    const inputComps  = components.filter((c) => (!c.getPorts().some(EmptyOutputPorts)));
+
+    // There cannot be input, output, and ambiguous components as this would be an ambigious case
+    if (inputComps.length > 0 && outputComps.length > 0 && ambiComps.length > 0)
+        return [[], []];
+
+    const [finalInputComps, finalOutputComps] = (() => {
+        // So, then there are only 3 cases:
+        //  Only input and output components are selected (no ambiguous components)
+        if (ambiComps.length === 0)
+            return [inputComps, outputComps];
+        //  Only input and ambiguous components are selected (no output components)
+        if (outputComps.length === 0)
+            return [inputComps, ambiComps];
+        //  Only output and ambiguous components are selected (no input components)
+        if (inputComps.length === 0)
+            return [ambiComps, outputComps];
+        return [[], []];
+    })();
+
+    return [
+        GetAllPorts(finalInputComps).filter(EmptyInputPorts),
+        GetAllPorts(finalOutputComps).filter(EmptyOutputPorts),
+    ];
+}
+
+
 export function CreateBusAction(outputPorts: OutputPort[], inputPorts: InputPort[]): GroupAction {
     if (inputPorts.length !== outputPorts.length)
         throw new Error("Expected equal size input and output ports to bus!");
@@ -67,15 +117,20 @@ export function CreateBusAction(outputPorts: OutputPort[], inputPorts: InputPort
 
     /* eslint-disable space-in-parens */
     // Associate the ports with their angle
-    const outputMap = new Map(outputAngles.map((a, i) => [a, outputPorts[i]]));
-    const inputMap  = new Map( inputAngles.map((a, i) => [a,  inputPorts[i]]));
-    /* eslint-enable space-in-parens */
+    //  Needs to be a map of arrays, in the case where two ports share the exact same angle
+    const outputMap = new Map<number, OutputPort[]>;
+    const inputMap  = new Map<number, InputPort[]>;
+
+    // Add each ports to the maps by angle
+    outputAngles.forEach((a, i) => outputMap.set(a, [...(outputMap.get(a) ?? []), outputPorts[i]]));
+     inputAngles.forEach((a, i) =>  inputMap.set(a, [...( inputMap.get(a) ?? []),  inputPorts[i]]));
 
     outputAngles.sort(sortByAngle);
     inputAngles.sort(sortByAngle).reverse();
 
     // Connect Ports according to their target pos on the Average Component
     return new GroupAction(inputAngles.map((inputAngle, i) =>
-        new ConnectionAction(designer, inputMap.get(inputAngle)!, outputMap.get(outputAngles[i])!)
+        // Pop the ports out of their map so they only get used once
+        new ConnectionAction(designer, inputMap.get(inputAngle)!.pop()!, outputMap.get(outputAngles[i])!.pop()!)
     ), "Bus Action");
 }

src/app/tests/digital/utils/actions/BusAction.test.ts

@@ -5,18 +5,18 @@ import {V, Vector} from "Vector";
 
 import {GetHelpers} from "test/helpers/Helpers";
 
-import {CreateBusAction} from "digital/actions/addition/BusActionFactory";
+import {CreateBusAction, GetComponentBusPorts} from "digital/actions/addition/BusActionFactory";
 
 import {DigitalCircuitDesigner, InputPort, OutputPort} from "digital/models";
 
-import {ANDGate, BCDDisplay, ConstantNumber, IC, ICData, LED, Multiplexer, Switch} from "digital/models/ioobjects";
+import {ANDGate, BCDDisplay, BUFGate, ConstantNumber, IC,
+        ICData, LED, Multiplexer, Switch} from "digital/models/ioobjects";
 
 
 describe("Bus Action", () => {
     const designer = new DigitalCircuitDesigner(0);
     const { Place } = GetHelpers(designer);
 
-
     function expectBusConnections(outs: OutputPort[], ins: InputPort[]) {
         // Helper functions to for expected connectivity
         const expectAllDisconnected = () => {
@@ -285,4 +285,88 @@ describe("Bus Action", () => {
         expect(i3.getConnections()[0]).toBe(ic.getConnections()[3]);
         expect(i4.getConnections()[0]).toBe(ic.getConnections()[1]);
     });
+    test("Switches at exact same position", () => {
+        const [i1, i2, i3, i4, bcd1] = Place(new Switch(), new Switch(), new Switch(),
+                                             new Switch(), new BCDDisplay());
+
+        i1.setPos(V(0,0));
+        i2.setPos(V(0,0));
+        i3.setPos(V(0,0));
+        i4.setPos(V(0,0));
+        bcd1.setPos(V(200,0));
+
+        // Expect every single switch to connect, but we can't assert anything about the order of connections
+        expectBusConnections([i1,i2,i3,i4].flatMap((i) => i.getOutputPorts()), bcd1.getInputPorts());
+    });
+
+    describe("Bus Components", () => {
+        // Buses that should work
+        test("Constant Number -> BCD Display", () => {
+            const [c1, bcd1] = Place(new ConstantNumber(), new BCDDisplay());
+
+            const [iports, oports] = GetComponentBusPorts([c1, bcd1]);
+
+            expect(iports).toHaveLength(4);
+            expect(oports).toHaveLength(4);
+
+            expectBusConnections(oports, iports);
+        });
+        test("4 Switches -> BCD Display", () => {
+            const [i1, i2, i3, i4, bcd1] = Place(new Switch(), new Switch(), new Switch(),
+                                                 new Switch(), new BCDDisplay());
+
+            const [iports, oports] = GetComponentBusPorts([i1, i2, bcd1, i3, i4]);
+
+            expect(iports).toHaveLength(4);
+            expect(oports).toHaveLength(4);
+
+            expectBusConnections(oports, iports);
+        });
+        test("4 Switches -> 2 ANDGates", () => {
+            const [i1, i2, i3, i4, a1, a2] = Place(new Switch(), new Switch(), new Switch(),
+                                                   new Switch(), new ANDGate(), new ANDGate());
+
+            const [iports, oports] = GetComponentBusPorts([i1, a2, i3, i2, i4, a1]);
+
+            expect(iports).toHaveLength(4);
+            expect(oports).toHaveLength(4);
+
+            expectBusConnections(oports, iports);
+        });
+        test("6 Switches -> Mux", () => {
+            const [i1, i2, i3, i4, i5, i6, m1] = Place(new Switch(), new Switch(), new Switch(), new Switch(),
+                                                       new Switch(), new Switch(), new Multiplexer());
+
+            const [iports, oports] = GetComponentBusPorts([i1, i2, i3, i4, i5, i6, m1]);
+
+            expect(iports).toHaveLength(6);
+            expect(oports).toHaveLength(6);
+
+            expectBusConnections(oports, iports);
+        });
+
+        // Buses that should not work
+        test("Fail: BUFGate -> BUFGate", () => {
+            const [b1, b2] = Place(new BUFGate(), new BUFGate());
+
+            const [iports, oports] = GetComponentBusPorts([b1, b2]);
+
+            expect(iports).not.toHaveLength(oports.length);
+        });
+        test("Fail: 3 Switches -> BCD Display", () => {
+            const [i1, i2, i3, bcd1] = Place(new Switch(), new Switch(), new Switch(), new BCDDisplay());
+
+            const [iports, oports] = GetComponentBusPorts([i1, i2, i3, bcd1]);
+
+            expect(iports).not.toHaveLength(oports.length);
+        });
+        test("Fail: 7 Switches -> Mux", () => {
+            const [i1, i2, i3, i4, i5, i6, i7, m1] = Place(new Switch(), new Switch(), new Switch(), new Switch(),
+                                                       new Switch(), new Switch(), new Switch(), new Multiplexer());
+
+            const [iports, oports] = GetComponentBusPorts([i1, i2, i3, i4, i5, i6, i7, m1]);
+
+            expect(iports).not.toHaveLength(oports.length);
+        });
+    });
 });

src/app/tests/digital/utils/tools/handlers/FitToScreenHandler.test.ts

@@ -0,0 +1,72 @@
+import {V} from "Vector";
+
+import {GetHelpers} from "test/helpers/Helpers";
+import {Setup}      from "test/helpers/Setup";
+
+import {ConstantLow} from "digital/models/ioobjects";
+
+import {LED} from "digital/models/ioobjects/outputs/LED";
+
+
+describe("FitToScreenHandler", () => {
+    const { input, designer, selections, camera } = Setup();
+    const { Place } = GetHelpers(designer);
+
+    afterEach(() => {
+        designer.reset();
+        selections.get().forEach((s) => selections.deselect(s));
+    });
+
+    test("Fit to Screen of a Single Object", () => {
+        Place(new ConstantLow());
+
+        expect(designer.getObjects()).toHaveLength(1)
+        expect(selections.amount()).toBe(0);
+
+        input.click(V(0, 0));
+
+        expect(selections.amount()).toBe(1);
+
+        input.pressKey("f")
+            .releaseKey("f");
+
+        expect(selections.amount()).toBe(1);
+        expect(camera.getPos()).toEqual(V(21.5, 0));
+
+    });
+
+    test("Fit to Screen with no objects", () => {
+
+        expect(designer.getObjects()).toHaveLength(0)
+        expect(selections.amount()).toBe(0);
+
+        input.pressKey("f")
+            .releaseKey("f");
+
+        expect(selections.amount()).toBe(0);
+        expect(camera.getPos()).toEqual(V(0, 0));
+
+    });
+
+    test("Fit to Screen of Two Connected Objects", () => {
+        const { Connect } = GetHelpers(designer);
+        const [lo, a] = Place(new ConstantLow(), new LED());
+
+        Connect(lo, a);
+
+        expect(designer.getObjects()).toHaveLength(2)
+        expect(designer.getWires()).toHaveLength(1);
+        expect(selections.amount()).toBe(0);
+
+        input.click(V(0, 0));
+
+        expect(selections.amount()).toBe(1);
+
+        input.pressKey("f")
+            .releaseKey("f");
+
+        expect(selections.amount()).toBe(1);
+        expect(camera.getPos()).toEqual(V(0, 40.5));
+
+    });
+});