@ondoher/enigma 1.0.13 → 1.0.14

package/README.md

@@ -440,7 +440,7 @@ let enigma = new Enigma("I", {reflector: 'B'});
 
 enigma.configure({
     rotors: ['III', 'VI', 'VIII'],
-    ringSetting: [1, 8, 13],
+    ringSettings: [1, 8, 13],
     plugs: 'AN EZ HK IJ LR MQ OT PV SW UX'
 });
 

package/bin/config.js

@@ -0,0 +1,11 @@
+
+/** @type {EnigmaConfig} */
+export const CONFIG = {
+	enigma: {
+		name: "I",
+		reflector: 'B',
+		rotors: ['III', 'VI', 'VIII'],
+		ringSettings: [1, 8, 13],
+		plugs: 'AN EZ HK IJ LR MQ OT PV SW UX'
+	}
+}

package/bin/enigma.js

@@ -0,0 +1,125 @@
+import parseArgs  from 'minimist';
+import { getOptions } from '../lib/utils/options.js';
+import { access, constants, readFile, writeFile } from 'node:fs/promises';
+import { CONFIG } from './config.js';
+import Enigma from 'enigma/Enigma';
+
+let argv = parseArgs(process.argv.slice(2));
+let params = argv._;
+let instructionText = '';
+
+/** @type {Options} */
+let defaultOptions = {
+	file: './enigma.json',
+	overwrite: false,
+	events: '',
+	step: false
+}
+
+/** @type {OptionsNameMap} */
+let nameMap = {
+	file: 'f',
+	overwrite: 'o',
+	events: 'e',
+	step: 's'
+}
+
+
+/** @type {Options} */
+let options = getOptions(defaultOptions, argv, nameMap);
+let command = params[0];
+
+/**
+ * Call this function to check if a file exists
+ *
+ * @param {String} name
+ * @returns {Promise<boolean>}
+ */
+async function fileExists(name) {
+	try {
+		await access(name, constants.R_OK | constants.W_OK);
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+
+/**
+ * Call this method to see if the config file exists
+ * @returns
+ */
+async function configExists() {
+	return await fileExists(options.file)
+}
+
+/**
+ *
+ * @returns {Promise<EnigmaConfig>}
+ */
+async function readConfig() {
+	if (!configExists) {
+		return CONFIG;
+	}
+
+	return JSON.parse(await readFile( options.file, 'utf-8'));
+
+}
+
+function instructions() {
+	console.log(instructionText);
+}
+
+/**
+ *
+ * @param {string} str
+ */
+function error(str) {
+	console.log(str);
+}
+
+async function init() {
+	if (await configExists() && !options.overwrite) {
+		error("cannot overwrite config file")
+		instructions();
+		return;
+	}
+
+	await writeFile(options.file, JSON.stringify(CONFIG, null, "    "), 'utf-8');
+}
+
+async function runEnigma() {
+	let config = await readConfig();
+	if (params.length > 1) {
+		config.encode = params[1];
+	}
+	let enigmaConfig = config.enigma;
+	if (!config.encode) {
+		error('no string to encode');
+		instructions();
+		return;
+	}
+	let { name, rotors, ringSettings, reflector, plugs} = enigmaConfig;
+	let enigma = new Enigma(name, {reflector});
+	enigma.configure({rotors, ringSettings, plugs})
+	let decoded = enigma.translate("", config.encode)
+}
+
+async function main() {
+	instructionText = await readFile('./instructions.txt', 'utf-8');
+	if (!command) {
+		instructions();
+		return;
+	}
+
+	switch (command) {
+		case "init":
+			await init();
+ 			break;
+
+		default:
+			instructions();
+			break;
+	}
+}
+
+await main();

package/bin/enigma.json

@@ -0,0 +1,17 @@
+{
+    "enigma": {
+        "name": "I",
+        "reflector": "B",
+        "rotors": [
+            "III",
+            "VI",
+            "VIII"
+        ],
+        "ringSettings": [
+            1,
+            8,
+            13
+        ],
+        "plugs": "AN EZ HK IJ LR MQ OT PV SW UX"
+    }
+}

package/bin/instructions.txt

@@ -0,0 +1 @@
+silly boy

package/bin/types.d.ts

@@ -0,0 +1,21 @@
+
+
+type Options = {
+	file?: string;
+	overwrite?: boolean;
+	events?: string;
+	step?: boolean;
+}
+
+type EnigmaConfig = {
+	enigma: {
+		name: string;
+		reflector: string;
+		rotors: string[],
+		ringSettings: number[] | string;
+		plugs: string | string[];
+	},
+	rotor?: string,
+	options?: Options,
+	encode?: string,
+}

package/jsconfig.json

@@ -2,8 +2,11 @@
   "compilerOptions": {
     "target": "es2022", // Or a newer version like "es2020"
     "module": "es2022",
-    "checkJs": true
-  },
+    "checkJs": true,
+    "baseUrl": "./",
+    "paths": {
+      "*": ["node_modules/@types/*", "*"]
+    }  },
   "exclude": [
     "node_modules"
   ],

package/lib/enigma/Enigma.js

@@ -127,12 +127,35 @@ export default class Enigma extends Encoder {
 	 * @public
 	 */
 	step() {
+		// Only the notches on the first two rotors effect stepping. One rotor's
+		// alphabet ring prevents the next rotor from turning unless the first
+		// rotor's notch is exposed. When a rotor does step, so does the
+		// previous  rotor  because they are attached by the notch in the
+		// previous rotor's  ring
+
+		// precalculate if and why a rotor should step, the first rotor is
+		// always engaged
+		/** @type {{engaged:boolean, nextEngaged: boolean}[]} */
+		let step = []
+
+		step[0] = {engaged: true, nextEngaged: false};
+
+		for (let idx = 1; idx < 3; idx++) {
+			let engaged = this._rotors[idx - 1].atTurnover();
+			let nextEngaged = idx < 2 && this._rotors[idx].atTurnover();
+
+			step[idx] = {engaged, nextEngaged};
+		}
+
 		this._rotors.forEach((rotor, idx) => {
 			if (rotor.isFixed()) return;
 
-			// This is the double stepping. Only do this for the middle rotor
-			if (rotor.willTurnover() && idx === 1) {
-				this.pending[idx] = true
+			if (step[idx].engaged || step[idx].nextEngaged) {
+				rotor.step();
+			}
+
+			// the double-step is caused by the the next rotor stepping
+			if (step[idx].nextEngaged) {
 				/** @type {EventData} */
 				let eventData = {
 					name: rotor.name,
@@ -141,18 +164,9 @@ export default class Enigma extends Encoder {
 					event: "double-step",
 					offset: rotor.offset,
 				}
-
 				this.fire('double-step', rotor.name, eventData);
-			};
-
-			if (this.pending[idx]) {
-				this.pending[idx] = false;
-				if (rotor.step()) this.pending[idx + 1] = true;
 			}
 		});
-
-		// The first rotor is always stepping
-		this.pending[0] = true;
 	}
 
 	/**

package/lib/enigma/EnigmaTypes.d.ts

@@ -147,7 +147,7 @@ type StepData = {
 	/** the ending rotor position */
 	stop: number;
 
-	/** the locations of the turnover points for this rotor */
+	/** true if the rotor has rotated to its turnover location */
 	turnover: boolean;
 }
 

package/lib/enigma/Rotor.js

@@ -5,6 +5,12 @@ import Encoder from "./Encoder.js";
  * Create an instance of this class to construct a Rotor object. The Rotor class
  * encapsulates many of the peculiar behaviors of the Enigma. All connector
  * values here are specified in physical space.
+ *
+ * There are three positioning systems to keep in mind. There is the logical
+ * position that map an input to an output as defined by the wiring. There is
+ * the physical position of the rotor in space as related to the location of the
+ * connectors, the rotation offset. And there is an additional adjustment, the
+ * ring setting, that moves the internal wiring against the rotational position.
  */
 export default class Rotor extends Encoder {
 	/**
@@ -18,6 +24,7 @@ export default class Rotor extends Encoder {
 		super(name, "Rotor", settings);
 		let { map = STANDARD_ALPHABET, turnovers = '', ringSetting = 0} = settings
 
+		this._settings = structuredClone(settings);
 		this.map = [...map];
 		this.rightMap = this.makeMap(map);
 		this.leftMap = this.makeReverseMap(this.rightMap);
@@ -36,6 +43,17 @@ export default class Rotor extends Encoder {
 		}, turnoverSet);
 	}
 
+	/**
+	 * @returns {RotorSetup}
+	 */
+	get settings() {
+		return this._settings;
+	}
+
+	// get offset() {
+	// 	return this._offset
+	// }
+
 	/**
 	 * Call this method to select the initial rotation of the rotor. This is a
 	 * letter offset from the logical 0 connector. The initial rotation will
@@ -83,13 +101,19 @@ export default class Rotor extends Encoder {
 	}
 
 	/**
-	 * Call this method to step the rotor
+	 * Call this method to step the rotor. This is only responsible for updating
+	 * the internal state. Double stepping is done by the enigma class
 	 *
 	 * @public
-	 *
-	 * @returns {Boolean} true if the next rotor should be stepped
 	 */
 	step() {
+		// let start = this.offset;
+
+		// // do the step
+		// this.offset = this.normalize(this.offset + 1);
+
+		// let stop = this.offset;
+
 		// Because the turnover notch is attached to the outer ring, and the
 		// logical coordinates are based on the wiring, the logical position of
 		// the notch for turnover needs to be adjusted to remove the ring offset.
@@ -111,26 +135,21 @@ export default class Rotor extends Encoder {
 			turnover, start, stop
 		}
 
-		// console.log("firing", eventData);
 		this.fire('step', this.name, eventData);
 
 		return turnover;
 	}
 
 	/**
-	 * Call this method to see if the next step on this rotor will lead to
-	 * turnover. The Enigma class will call this on the middle rotor to handle
-	 * double stepping.
+	 * Call this method to see if the router turnover notch is exposed.
 	 *
 	 * @public
 	 *
-	 * @returns true if this rotor will turnover on the next step
+	 * @returns true if it is, false otherwise
 	 */
-	willTurnover() {
-		let turnoverOffset = this.normalize(this.offset + this.ringOffset);
-
-		// double stepping happens when we step to the turnover point
-		return this._turnovers.has(turnoverOffset);
+	atTurnover() {
+		let currentOffset = this.normalize(this.offset + this.ringOffset);
+		return this._turnovers.has(currentOffset);
 	}
 
 

package/lib/enigma/tests/RotorSpec.js

@@ -11,7 +11,7 @@ describe('Rotor Test Cases', function() {
 				map: rotorData.createData.map,
 			});
 
-			expect(rotor.leftMap).toEqual(rotorData.createData.reverseMap)
+			expect(rotor["leftMap"]).toEqual(rotorData.createData.reverseMap)
 		});
 
 		it('sets the length to the map length', function() {
@@ -20,7 +20,7 @@ describe('Rotor Test Cases', function() {
 				map: rotorData.createData.map,
 			});
 
-			expect(rotor.length).toEqual(rotorData.createData.map.length)
+			expect(rotor["length"]).toEqual(rotorData.createData.map.length)
 		});
 
 		it('remembers multiple turnovers', function() {
@@ -88,7 +88,7 @@ describe('Rotor Test Cases', function() {
 
 			it('handles double step', function() {
 				rotor.setStartPosition('Q');
-				let result = rotor.willTurnover();
+				let result = rotor.atTurnover();
 				expect(result).toBe(true);
 			});
 
@@ -115,7 +115,7 @@ describe('Rotor Test Cases', function() {
 			it('handles double step', function() {
 				rotor.ringOffset = 1;
 				rotor.setStartPosition('Q');
-				let result = rotor.willTurnover();
+				let result = rotor.atTurnover();
 				expect(result).toBe(true);
 			});
 

package/lib/utils/options.js

@@ -0,0 +1,63 @@
+import * as minimist from "minimist";
+
+/**
+ * Call this method to try to convert the input value to a
+ * boolean value, if not the return result will be the value passed in
+ *
+ * @param {string | number | boolean} val - the value to check
+ * @returns {string | boolean | number} the converted boolean or the input value
+ */
+function checkBoolean(val) {
+	let boolValues = {
+		'true' : true,
+		'false': false,
+		'on': true,
+		'off': false,
+		'set': true,
+		'clear': false,
+	}
+
+    if (val === true) return true;
+    if (val === false) return false;
+
+	return boolValues[val] !== undefined ? boolValues[val] : val;
+}
+
+/**
+ * Call this method to get the value of an option from the cli. It will convert
+ * this value to a boolean if it can.
+ *
+ * @param {minimist.ParsedArgs} argv - the parsed command line
+ * @param {String} name - the full name of the option
+ * @param {String} short - the short name of the optio
+ * @returns {OptionsValue} the value of the option
+ */
+export function getOption(argv, name, short) {
+	if (argv[name] !== undefined) return checkBoolean(argv[name]);
+	if (argv[short] != undefined) return checkBoolean(argv[short]);
+}
+
+/**
+ * Call this method to parse all the command line options, those
+ * that start with either - or --.
+ *
+ * @param {OptionValues} defaults - The default values, these will be returned if they are unchanged
+ * @param {minimist.ParsedArgs} argv - the parsed command line
+ * @param {OptionsNameMap} nameMap - a mapping between the full name and the short name
+ * @returns {OptionValues} the parsed options
+ */
+export function getOptions(defaults, argv, nameMap) {
+    let longNames = Object.keys(nameMap);
+    let options = structuredClone(defaults);
+
+    options = longNames.reduce(function(options, long) {
+        let short = nameMap[long];
+        let option = getOption(argv, long, short);
+
+        options[long] = option ?? options[long];
+
+        return options;
+    }, options);
+
+    return options;
+}

package/lib/utils/optionsTypes.d.ts

@@ -0,0 +1,5 @@
+
+type OptionsValue = string | number | boolean
+type OptionValues = {[name: string]: OptionsValue}
+
+type OptionsNameMap = {[name: string]: string}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ondoher/enigma",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "Enigma machine simulator with tools and documentation to help you build your own.",
   "main": "./lib/index.js",
   "types": "./types/index.d.ts",
@@ -27,12 +27,14 @@
   "homepage": "https://github.com/Ondoher/enigma#readme",
   "type": "module",
   "devDependencies": {
-    "@types/node": "^25.0.10",
     "@types/jasmine": "^4.6.6",
-    "undici-types": "^7.19.0",
+    "@types/node": "^25.0.10",
     "jasmine": "^4.5.0",
-    "jasmine-console-reporter": "^3.1.0"
+    "jasmine-console-reporter": "^3.1.0",
+    "undici-types": "^7.19.0"
   },
   "dependencies": {
+    "@types/minimist": "^1.2.5",
+    "minimist": "^1.2.8"
   }
 }