Support setting Alfred variables with alfy.output (#43)

index.js

@@ -38,8 +38,51 @@ alfy.alfred = {
 
 alfy.input = process.argv[2];
 
-alfy.output = arr => {
-	console.log(JSON.stringify({items: arr}, null, '\t'));
+const isDefined = x => x !== null && x !== undefined;
+
+const wrapArg = item => {
+	const alfredworkflow = {arg: item.arg, variables: item.variables};
+	const arg = JSON.stringify({alfredworkflow});
+	const newItem = Object.assign({}, item, {arg});
+	delete newItem.variables;
+	return newItem;
+};
+
+const formatMods = item => {
+	const copy = Object.assign({}, item);
+
+	Object.keys(item.mods).forEach(modKey => {
+		const modItem = item.mods[modKey];
+		copy.mods[modKey] = wrapArg(modItem);
+	});
+
+	return copy;
+};
+
+// see https://www.alfredforum.com/topic/9070-how-to-workflowenvironment-variables/
+// for documentation on setting environment variables from Alfred workflows
+const format = item => {
+	if (!isDefined(item)) {
+		return item;
+	}
+
+	if (isDefined(item.variables)) {
+		item = wrapArg(item);
+	}
+
+	if (isDefined(item.mods)) {
+		item = formatMods(item);
+	}
+
+	return item;
+};
+
+alfy.output = items => {
+	if (Array.isArray(items)) {
+		items = items.map(format);
+	}
+
+	console.log(JSON.stringify({items}, null, '\t'));
 };
 
 alfy.matches = (input, list, item) => {

readme.md

@@ -165,7 +165,7 @@ Return output to Alfred.
 
 Type: `Array`
 
-List of `Object` with any of the [supported properties](https://www.alfredapp.com/help/workflows/inputs/script-filter/json/).
+List of `Object` with any of the [supported properties](https://www.alfredapp.com/help/workflows/inputs/script-filter/json/). In addition, if a list item has a `variables` property, it will be used to set Alfred's [Workflow Environment Variables](https://www.alfredapp.com/help/workflows/advanced/variables/) if the user selects the item. More info on environment variables is [here](https://www.alfredforum.com/topic/9070-how-to-workflowenvironment-variables/).
 
 Example:
 
@@ -179,6 +179,40 @@ alfy.output([{
 
 <img src="media/screenshot-output.png" width="694">
 
+Using the `variables` property:
+
+```js
+alfy.output([
+  {
+    title: 'Unicorn',
+    arg: '🦄',
+    variables: {
+      color: 'white'
+    }
+  },
+  {
+    title: 'Rainbow',
+    arg: '🌈',
+    variables: {
+      color: 'myriad'
+    }
+  }
+]);
+```
+
+You can access Alfred Workflow Variables through `process.env`:
+
+```js
+// After a user selects "Unicorn" or "Rainbow"
+process.env.color
+//=> 'white' if they selected Unicorn
+//=> 'myriad' if they selected Rainbow
+```
+
+Alfred Workflow Variables are also available in the workflow editor using the form `{var:varname}`. For example, `{var:color}` 
+
+<img src="media/screenshot-variable.png" width="694">
+
 #### matches(input, list, [item])
 
 Returns an `Array` of items in `list` that case-insensitively contains `input`.

test/output.js

@@ -0,0 +1,128 @@
+import {serial as test} from 'ava';
+import hookStd from 'hook-std';
+import {alfy} from './_utils';
+
+const m = alfy();
+const hook = cb => {
+	const unhook = hookStd.stdout({silent: true}, output => {
+		unhook();
+		if (cb) {
+			cb(output);
+		}
+	});
+};
+
+test.cb('.output() properly wraps item.variables', t => {
+	hook(output => {
+		const item = JSON.parse(output).items[0];
+		const arg = JSON.parse(item.arg);
+		t.deepEqual(arg, {
+			alfredworkflow: {
+				arg: '🦄',
+				variables: {fabulous: true}
+			}
+		});
+		t.end();
+	});
+	m.output([{
+		title: 'unicorn',
+		arg: '🦄',
+		variables: {fabulous: true}
+	}]);
+});
+
+test.cb('.output() wraps item.variables even if item.arg is not defined', t => {
+	hook(output => {
+		const item = JSON.parse(output).items[0];
+		const arg = JSON.parse(item.arg);
+		t.deepEqual(arg, {
+			alfredworkflow: {
+				variables: {fabulous: true}
+			}
+		});
+		t.end();
+	});
+	m.output([{
+		title: 'unicorn',
+		variables: {fabulous: true}
+	}]);
+});
+
+test.cb('.output() does not wrap item.arg if item.variables is not defined', t => {
+	hook(output => {
+		const item = JSON.parse(output).items[0];
+		t.is(item.arg, '🦄');
+		t.is(item.variables, undefined);
+		t.end();
+	});
+	m.output([{
+		title: 'unicorn',
+		arg: '🦄'
+	}]);
+});
+
+test('.output() accepts null and undefined items', t => {
+	hook();
+	t.notThrows(() => m.output([undefined, null]));
+});
+
+test('.output() accepts non-arrays', t => {
+	let done = false;
+	const unhook = hookStd.stdout({silent: true}, () => {
+		if (done) {
+			unhook();
+		}
+	});
+	t.notThrows(() => m.output({}));
+	t.notThrows(() => m.output('unicorn'));
+	t.notThrows(() => m.output(null));
+	done = true;
+	t.notThrows(() => m.output(undefined));
+});
+
+const itemWithMod = {
+	title: 'unicorn',
+	arg: '🦄',
+	variables: {fabulous: true},
+	mods: {
+		alt: {
+			title: 'Rainbow',
+			arg: '🌈',
+			variables: {
+				color: 'myriad'
+			}
+		}
+	}
+};
+
+test.cb('.output() wraps mod items', t => {
+	hook(output => {
+		const item = JSON.parse(output).items[0];
+		const altArg = JSON.parse(item.mods.alt.arg);
+		t.deepEqual(altArg, {
+			alfredworkflow: {
+				arg: '🌈',
+				variables: {
+					color: 'myriad'
+				}
+			}
+		});
+		t.end();
+	});
+	m.output([itemWithMod]);
+});
+
+test.cb('.output() doesn\'t change original item when mod items are present', t => {
+	hook(output => {
+		const item = JSON.parse(output).items[0];
+		const arg = JSON.parse(item.arg);
+		t.deepEqual(arg, {
+			alfredworkflow: {
+				arg: '🦄',
+				variables: {fabulous: true}
+			}
+		});
+		t.end();
+	});
+	m.output([itemWithMod]);
+});