Refactoring tests and moving code to common module

1. All tests have been converted into regular command-line mocha
   tests (instead of running in the browser), and the deployment
   script has been changed to automatically fail any `--new`
   deployment which doesn't pass.
2. Several small class (e.g., `Logger`) have been moved into a common
   module, `crafting-guide-common` so that they may be shared between
   the client and server.

test/crafting_plan.test.coffee

@@ -0,0 +1,84 @@
+###
+Crafting Guide - crafting_plan.test.coffee
+
+Copyright (c) 2014-2015 by Redwood Labs
+All rights reserved.
+###
+
+CraftingPlan = require '../src/coffee/models/crafting_plan'
+ItemSlug     = require '../src/coffee/models/item_slug'
+Mod          = require '../src/coffee/models/mod'
+ModPack      = require '../src/coffee/models/mod_pack'
+ModVersion   = require '../src/coffee/models/mod_version'
+
+########################################################################################################################
+
+modPack = plan = null
+
+########################################################################################################################
+
+describe 'crafting_plan.coffee', ->
+
+    beforeEach ->
+        mod = new Mod name:'Minecraft', slug:'minecraft'
+        mod.addModVersion new ModVersion modSlug:mod.slug, version:'1.7.10'
+        mod.activeModVersion.parse """
+            schema:1
+
+            item:Oak Plank;      recipe:; input:Oak Log;                pattern:... .0. ...; quantity:4
+            item:Stick;          recipe:; input:Oak Plank;              pattern:... .0. .0.; quantity:4
+            item:Crafting Table; recipe:; input:Oak Plank;              pattern:00. 00. ...
+            item:Furnace;        recipe:; input:Cobblestone;            pattern:000 0.0 000; tools:Crafting Table
+            item:Iron Ingot;     recipe:; input:Iron Ore, furnace fuel; pattern:.0. ... .1.; tools:Furnace
+            item:Iron Sword;     recipe:; input:Iron Ingot, Stick;      pattern:.0. .0. .1.; tools:Crafting Table
+        """
+        modPack = new ModPack
+        modPack.addMod mod
+
+        plan = new CraftingPlan modPack:modPack, includingTools:false
+
+    describe 'craft', ->
+
+        describe 'under the simplest conditions', ->
+
+            it 'can craft a single step recipe', ->
+                plan.want.add ItemSlug.slugify 'oak_plank'
+                plan.craft()
+                plan.need.unparse().should.equal 'oak_log'
+                plan.result.unparse().should.equal '4.oak_plank'
+
+            it 'can craft a multi-step recipe', ->
+                plan.want.add ItemSlug.slugify 'crafting_table'
+                plan.craft()
+                plan.need.unparse().should.equal 'oak_log'
+                plan.result.unparse().should.equal 'crafting_table'
+
+            it 'can craft a multi-step recipe using tools', ->
+                plan.want.add ItemSlug.slugify 'furnace'
+                plan.craft()
+                plan.need.unparse().should.equal '8.cobblestone'
+                plan.result.unparse().should.equal 'furnace'
+
+            it 'can craft a multi-step recipe re-using tools', ->
+                plan.want.add ItemSlug.slugify 'iron_sword'
+                plan.craft()
+                plan.need.unparse().should.equal '2.furnace_fuel:2.iron_ore:oak_log'
+                plan.result.unparse().should.equal 'iron_sword:2.oak_plank:3.stick'
+
+        describe 'with building tools', ->
+
+            it 'can craft a multi-step recipe using tools', ->
+                plan.includingTools = true
+                plan.want.add ItemSlug.slugify 'furnace'
+                plan.craft()
+                plan.need.unparse().should.equal '8.cobblestone:oak_log'
+                plan.result.unparse().should.equal 'crafting_table:furnace'
+
+            it 'can craft a multi-step recipe re-using tools', ->
+                plan.includingTools = true
+                plan.want.add ItemSlug.slugify 'iron_sword'
+                plan.craft()
+
+                plan.need.unparse().should.eql '8.cobblestone:2.furnace_fuel:2.iron_ore:2.oak_log'
+                plan.result.unparse().should.equal 'crafting_table:furnace:' +
+                    'iron_sword:2.oak_plank:3.stick'

test/event_recorder.coffee

@@ -0,0 +1,28 @@
+###
+# Crafting Guide - event_recorder.coffee
+#
+# Copyright (c) 2014-2015 by Redwood Labs
+# All rights reserved.
+###
+
+util = require 'util'
+
+########################################################################################################################
+
+module.exports = class EventRecorder
+
+    constructor: (model)->
+        if not model? then throw new Error 'model is required'
+
+        @model = model
+        @events = []
+
+        Object.defineProperty this, 'names', get:-> e.event for e in @events
+
+        @model.on 'all', (event, model, args...)=>
+            logger.verbose -> "#{model?.constructor?.name}(#{model?.cid}) emitted #{event}
+                with args: #{util.inspect(args)}"
+            @events.push id:model?.cid, event:event, args:args
+
+    reset: ->
+        @events = []

test/inventory.test.coffee

@@ -0,0 +1,211 @@
+###
+# Crafting Guide - inventory.test.coffee
+#
+# Copyright (c) 2014-2015 by Redwood Labs
+# All rights reserved.
+###
+
+{Event}       = require '../src/coffee/constants'
+EventRecorder = require './event_recorder'
+Inventory     = require '../src/coffee/models/inventory'
+Item          = require '../src/coffee/models/item'
+ItemSlug      = require '../src/coffee/models/item_slug'
+
+########################################################################################################################
+
+inventory = modPack = null
+
+########################################################################################################################
+
+describe 'inventory.coffee', ->
+
+    beforeEach ->
+        inventory = new Inventory {}, silent:false
+        inventory.add ItemSlug.slugify('wool'), 4
+        inventory.add ItemSlug.slugify('string'), 20
+        inventory.add ItemSlug.slugify('boat')
+
+    describe 'add', ->
+
+        it 'can add to an empty inventory', ->
+            inventory.add ItemSlug.slugify('iron_ingot'), 4
+            stack = inventory._stacks['iron_ingot']
+            stack.constructor.name.should.equal 'Stack'
+            stack.itemSlug.qualified.should.equal 'iron_ingot'
+            stack.quantity.should.equal 4
+
+        it 'can augment quantity of existing items', ->
+            inventory.add ItemSlug.slugify('wool'), 2
+            inventory.unparse().should.equal 'boat:20.string:6.wool'
+
+        it 'can add zero quantity', ->
+            inventory.add ItemSlug.slugify('wool'), 0
+            inventory.unparse().should.equal 'boat:20.string:4.wool'
+
+        it 'emits the proper events', ->
+            events = new EventRecorder inventory
+            inventory.add ItemSlug.slugify('iron_ingot'), 10
+            events.names.should.eql [Event.add, Event.change]
+
+    describe 'addInventory', ->
+
+        it 'can add to an empty inventory', ->
+            newInventory = new Inventory
+            newInventory.addInventory inventory
+            newInventory.unparse().should.equal 'boat:20.string:4.wool'
+
+        it 'can add a mix of new and existing items', ->
+            newInventory = new Inventory
+            newInventory.add ItemSlug.slugify('string'), 2
+            newInventory.addInventory inventory
+            newInventory.unparse().should.equal 'boat:22.string:4.wool'
+
+    describe 'clone', ->
+
+        it 'creates an empty inventory from an empty inventory', ->
+            a = new Inventory
+            b = a.clone()
+            b._itemSlugs.should.eql []
+
+        it 'faithfully copies an existing inventory', ->
+            copy = inventory.clone()
+            copy.unparse().should.equal 'boat:20.string:4.wool'
+
+    describe 'each', ->
+
+        it 'works with an empty inventory', ->
+            inventory = new Inventory
+            result = []
+            inventory.each (item)-> result.push item.name
+            result.should.eql []
+
+        it 'works when items have only been added', ->
+            result = []
+            inventory.each (stack)-> result.push stack.itemSlug.qualified
+            result.should.eql ['boat', 'string', 'wool']
+
+        it 'works when items have been augmented', ->
+            inventory.add ItemSlug.slugify 'iron_ingot'
+            inventory.add ItemSlug.slugify 'boat'
+            inventory.add ItemSlug.slugify('wool'), 2
+
+            result = []
+            inventory.each (stack)-> result.push stack.itemSlug.qualified
+            result.should.eql ['boat', 'iron_ingot', 'string', 'wool']
+
+    describe 'hasAtLeast', ->
+
+        it 'works when the item is completely absent', ->
+            answer = inventory.hasAtLeast 'chicken', 1
+            answer.should.be.false
+
+        it 'always returns true for zero quantity', ->
+            inventory.hasAtLeast('chicken', 0).should.be.true
+            inventory.hasAtLeast('wool', 0).should.be.true
+
+        it 'works for a quantity above 1', ->
+            inventory.hasAtLeast('wool', 3).should.be.true
+            inventory.hasAtLeast('wool', 4).should.be.true
+            inventory.hasAtLeast('wool', 5).should.be.false
+
+    describe 'localize', ->
+
+        before ->
+            modPack =
+                modSlug:
+                    wool:       'minecraft'
+                    string:     'minecraft'
+                    boat:       'minecraft'
+                    stone_gear: 'buildcraft'
+                findItem: (slug)->
+                    return slug:new ItemSlug @modSlug[slug.item], slug.item
+
+        it 'replaces item slugs with qualified slugs', ->
+            inventory.add ItemSlug.slugify 'stone_gear'
+            inventory.modPack = modPack
+            inventory.localize()
+
+            slugs = []
+            inventory.each (stack)-> slugs.push stack.itemSlug.qualified
+            slugs.should.eql [
+                'minecraft__boat'
+                'minecraft__string'
+                'minecraft__wool'
+                'buildcraft__stone_gear'
+            ]
+
+        it 'ignores qualified slugs', ->
+            inventory.add ItemSlug.slugify 'buildcraft__stone_gear'
+            inventory.modPack = modPack
+            inventory.localize()
+
+            slugs = []
+            inventory.each (stack)-> slugs.push stack.itemSlug.qualified
+            slugs.should.eql [
+                'minecraft__boat'
+                'minecraft__string'
+                'minecraft__wool'
+                'buildcraft__stone_gear'
+            ]
+
+    describe 'parse', ->
+
+        beforeEach ->
+            inventory = new Inventory {}, silent:false
+
+        it 'ignores an empty string', ->
+            result = inventory.parse ''
+            result.unparse().should.eql ''
+
+        it 'can parse a single item without quantity', ->
+            result = inventory.parse 'wool'
+            result.unparse().should.equal 'wool'
+
+        it 'can parse a single item with quantity', ->
+            result = inventory.parse '4.wool'
+            result.unparse().should.equal '4.wool'
+
+        it 'can parse multiple mixed-type items', ->
+            result = inventory.parse '4.wool:10.string:boat'
+            result.unparse().should.equal 'boat:10.string:4.wool'
+
+    describe 'pop', ->
+
+        it 'returns null for an empty inventory', ->
+            inventory = new Inventory
+            result = inventory.pop()
+            expect(result).to.be.null
+
+        it 'completely removes the last item', ->
+            stack = inventory.pop()
+            stack.itemSlug.qualified.should.equal 'wool'
+            stack.quantity.should.equal 4
+            inventory.unparse().should.equal 'boat:20.string'
+
+        it 'triggers the right events', ->
+            events = new EventRecorder inventory
+            result = inventory.pop()
+            events.names.should.eql [Event.remove, Event.change]
+
+    describe 'remove', ->
+
+        it 'throws when the item is absent', ->
+            expect(-> inventory.remove('chicken')).to.throw Error,
+                'cannot remove chicken since it is not in this inventory'
+
+        it 'throws when the item has insufficient quantity', ->
+            expect(-> inventory.remove('wool', 10)).to.throw Error,
+                'cannot remove 10: only 4 wool in this inventory'
+
+        it 'removes all items by default', ->
+            inventory.remove 'wool'
+            expect(inventory._stacks.wool).to.be.empty
+
+        it 'removes a quantity above 1', ->
+            inventory.remove 'wool', 3
+            inventory._stacks.wool.quantity.should.equal 1
+
+        it 'emits the proper events', ->
+            events = new EventRecorder inventory
+            inventory.remove 'wool'
+            events.names.should.eql [Event.change, Event.remove, Event.change]

test/item_slug.test.coffee

@@ -0,0 +1,136 @@
+###
+Crafting Guide - item_slug.coffee
+
+Copyright (c) 2015 by Redwood Labs
+All rights reserved.
+###
+
+ItemSlug = require '../src/coffee/models/item_slug'
+
+########################################################################################################################
+
+describe 'item_slug.coffee', ->
+
+    describe 'constructor', ->
+
+        it 'can handle one argument', ->
+            slug = new ItemSlug 'alpha'
+            slug.item.should.equal 'alpha'
+            expect(slug.mod).to.be.null
+            slug.qualified.should.equal 'alpha'
+
+        it 'can handle two arguments', ->
+            slug = new ItemSlug 'alpha', 'bravo'
+            slug.mod.should.equal 'alpha'
+            slug.item.should.equal 'bravo'
+            slug.qualified.should.equal 'alpha__bravo'
+
+        it 'throws with zero arguments', ->
+            f = -> new ItemSlug
+            expect(f).to.throw Error, 'expected arguments to be "modSlug, itemSlug" or just "itemSlug"'
+
+        it 'throws with more arguments', ->
+            f = -> new ItemSlug 'alpha', 'bravo', 'charlie'
+            expect(f).to.throw Error, 'expected arguments to be "modSlug, itemSlug" or just "itemSlug"'
+
+    describe 'ItemSlug.compare', ->
+
+        it 'sorts qualified slugs first', ->
+            a = new ItemSlug 'alpha'
+            b = new ItemSlug 'bravo', 'charlie'
+
+            ItemSlug.compare(a, b).should.equal +1
+            ItemSlug.compare(b, a).should.equal -1
+
+        it 'sorts by mod when both are qualified', ->
+            a = new ItemSlug 'alpha', 'bravo'
+            b = new ItemSlug 'charlie', 'delta'
+
+            ItemSlug.compare(a, b).should.equal -1
+            ItemSlug.compare(b, a).should.equal +1
+
+        it 'sorts by item when both are qualified in the same mod', ->
+            a = new ItemSlug 'alpha', 'bravo'
+            b = new ItemSlug 'charlie', 'bravo'
+
+            ItemSlug.compare(a, b).should.equal -1
+            ItemSlug.compare(b, a).should.equal +1
+
+        it 'sorts by item when not qualified', ->
+            a = new ItemSlug 'alpha'
+            b = new ItemSlug 'bravo'
+
+            ItemSlug.compare(a, b).should.equal -1
+            ItemSlug.compare(b, a).should.equal +1
+
+    describe 'ItemSlug.equal', ->
+
+        it 'requires both to have the same mod', ->
+            a = new ItemSlug 'alpha', 'bravo'
+            b = new ItemSlug 'alpha', 'charlie'
+            c = new ItemSlug 'alpha', 'bravo'
+
+            ItemSlug.equal(a, b).should.be.false
+            ItemSlug.equal(a, c).should.be.true
+
+        it 'requires both to have the same item', ->
+            a = new ItemSlug 'alpha', 'bravo'
+            b = new ItemSlug 'alpha', 'charlie'
+            c = new ItemSlug 'alpha', 'bravo'
+
+            ItemSlug.equal(a, b).should.be.false
+            ItemSlug.equal(a, c).should.be.true
+
+    describe 'ItemSlug.slugify', ->
+
+        it 'can slugify a pure name', ->
+            slug = ItemSlug.slugify 'Alpha Bravo (Charlie)'
+            slug.item.should.equal 'alpha_bravo_charlie'
+            expect(slug.mod).to.be.null
+
+        it 'can slugify a simple item slug', ->
+            slug = ItemSlug.slugify 'alpha_bravo_charlie'
+            slug.item.should.equal 'alpha_bravo_charlie'
+            expect(slug.mod).to.be.null
+
+        it 'can slugify a fully-qualified slug', ->
+            slug = ItemSlug.slugify 'alpha_bravo__charlie_delta'
+            slug.mod.should.equal 'alpha_bravo'
+            slug.item.should.equal 'charlie_delta'
+
+    describe 'matches', ->
+
+        it 'ignores mod when either is unqualified', ->
+            a = new ItemSlug 'alpha', 'bravo'
+            b = new ItemSlug 'bravo'
+            c = new ItemSlug 'charlie'
+
+            a.matches(b).should.be.true
+            a.matches(c).should.be.false
+
+        it 'observes differences in mod when all are qualified', ->
+            a = new ItemSlug 'alpha', 'bravo'
+            b = new ItemSlug 'charlie', 'bravo'
+            c = new ItemSlug 'delta', 'echo'
+            d = new ItemSlug 'alpha', 'bravo'
+
+            a.matches(b).should.be.false
+            a.matches(c).should.be.false
+            a.matches(d).should.be.true
+
+    describe 'isQualified', ->
+
+        it 'returns true only when the mod slug is set', ->
+            a = new ItemSlug 'alpha', 'bravo'
+            b = new ItemSlug 'charlie'
+            a.isQualified.should.be.true
+            b.isQualified.should.be.false
+
+    describe '[]', ->
+
+        it 'allows slugs as a key', ->
+            slug = new ItemSlug 'alpha', 'bravo'
+            data = {}
+            data[slug] = 'foo'
+            data['alpha__bravo'].should.equal 'foo'
+            data[slug].should.equal 'foo'

test/mod.test.coffee

@@ -0,0 +1,30 @@
+###
+Crafting Guide - mod.test.coffee
+
+Copyright (c) 2015 by Redwood Labs
+All rights reserved.
+###
+
+Mod = require '../src/coffee/models/mod'
+
+########################################################################################################################
+
+mod = null
+
+########################################################################################################################
+
+describe 'mod.coffee', ->
+
+    beforeEach -> mod = new Mod name:'Test', slug:'test'
+
+    describe 'compareTo', ->
+
+        it 'lists required mods first', ->
+            minecraft = new Mod name:'Minecraft', slug:'minecraft'
+            mod.compareTo(minecraft).should.equal +1
+            minecraft.compareTo(mod).should.equal -1
+
+        it 'sorts by name second', ->
+            buildcraft = new Mod name:'Buildcraft', slug:'buildcraft'
+            mod.compareTo(buildcraft).should.equal +1
+            buildcraft.compareTo(mod).should.equal -1

test/mod_pack.test.coffee

@@ -0,0 +1,103 @@
+###
+Crafting Guide - mod_pack.test.coffee
+
+Copyright (c) 2014-2015 by Redwood Labs
+All rights reserved.
+###
+
+Item       = require '../src/coffee/models/item'
+ItemSlug   = require '../src/coffee/models/item_slug'
+Mod        = require '../src/coffee/models/mod'
+ModPack    = require '../src/coffee/models/mod_pack'
+ModVersion = require '../src/coffee/models/mod_version'
+
+########################################################################################################################
+
+buildcraft = industrialCraft = minecraft = modPack = null
+
+########################################################################################################################
+
+describe 'mod_pack.coffee', ->
+
+    beforeEach ->
+        minecraft = new Mod slug:'minecraft', name:'Minecraft'
+        minecraft.addModVersion new ModVersion modSlug:minecraft.slug, version:'1.7.10'
+        minecraft.activeModVersion.addItem new Item name:'Wool'
+        minecraft.activeModVersion.addItem new Item name:'Bed', recipes:['']
+        minecraft.activeModVersion.registerName ItemSlug.slugify('iron_chestplate'), 'Iron Chestplate'
+
+        buildcraft = new Mod slug:'buildcraft', name:'Buildcraft'
+        buildcraft.addModVersion new ModVersion modSlug:buildcraft.slug, version:'6.2.6'
+        buildcraft.activeModVersion.addItem new Item name:'Stone Gear', recipes:['']
+        buildcraft.activeModVersion.addItem new Item name:'Wrench', recipes:['']
+        buildcraft.activeVersion = Mod.Version.None
+
+        industrialCraft = new Mod slug:'industrial_craft', name:'Industrial Craft'
+        industrialCraft.addModVersion new ModVersion modSlug:industrialCraft.slug, version:'2.0'
+        industrialCraft.activeModVersion.addItem new Item name:'Resin'
+        industrialCraft.activeModVersion.addItem new Item name:'Rubber'
+        industrialCraft.activeModVersion.addItem new Item name:'Wrench', recipes:['']
+        industrialCraft.activeVersion = Mod.Version.None
+
+        modPack = new ModPack
+        modPack.addMod minecraft
+        modPack.addMod buildcraft
+        modPack.addMod industrialCraft
+
+    describe 'findItem', ->
+
+        it 'can find an item by partial slug', ->
+            item = modPack.findItem ItemSlug.slugify 'wool'
+            item.slug.qualified.should.equal 'minecraft__wool'
+
+        it 'can find an item by full slug', ->
+            item = modPack.findItem ItemSlug.slugify 'minecraft__wool'
+            item.name.should.equal 'Wool'
+
+        it 'can find an ambiguous item by full slug', ->
+            buildcraft.activeVersion = Mod.Version.Latest
+            industrialCraft.activeVersion = Mod.Version.Latest
+            item = modPack.findItem ItemSlug.slugify 'industrial_craft__wrench'
+            item.name.should.equal 'Wrench'
+            item.modVersion.mod.name.should.equal 'Industrial Craft'
+
+        it 'can find an ambiguous item by partial slug', ->
+            buildcraft.activeVersion = Mod.Version.Latest
+            industrialCraft.activeVersion = Mod.Version.Latest
+            item = modPack.findItem ItemSlug.slugify 'wrench'
+            item.name.should.equal 'Wrench'
+            item.modVersion.mod.name.should.equal 'Buildcraft'
+
+    describe 'findItemByName', ->
+
+        it 'finds the requested item', ->
+            item = modPack.findItemByName 'Bed'
+            item.name.should.equal 'Bed'
+
+        it 'ignores disabled mod versions', ->
+            item = modPack.findItemByName 'Stone Gear'
+            expect(item).to.be.null
+
+    describe 'findItemDisplay', ->
+
+        it 'returns all data for a regular Minecraft item', ->
+            display = modPack.findItemDisplay ItemSlug.slugify 'bed'
+            display.iconUrl.should.equal '/browse/minecraft/bed/icon.png'
+            display.itemUrl.should.equal '/browse/minecraft/bed/'
+            display.itemName.should.equal 'Bed'
+            display.modSlug.should.equal 'minecraft'
+
+        it 'returns all data for an item in an enabled mod', ->
+            buildcraft.activeVersion = '6.2.6'
+            display = modPack.findItemDisplay ItemSlug.slugify 'stone_gear'
+            display.iconUrl.should.equal '/browse/buildcraft/stone_gear/icon.png'
+            display.itemUrl.should.equal '/browse/buildcraft/stone_gear/'
+            display.itemName.should.equal 'Stone Gear'
+            display.modSlug.should.equal 'buildcraft'
+
+        it 'assumes an unfound item is from Minecraft', ->
+            display = modPack.findItemDisplay ItemSlug.slugify 'iron_chestplate'
+            display.iconUrl.should.equal '/browse/minecraft/iron_chestplate/icon.png'
+            display.itemUrl.should.equal '/browse/minecraft/iron_chestplate/'
+            display.itemName.should.equal 'Iron Chestplate'
+            display.modSlug.should.equal 'minecraft'

test/mod_version.test.coffee

@@ -0,0 +1,96 @@
+###
+Crafting Guide - mod_version.test.coffee
+
+Copyright (c) 2014-2015 by Redwood Labs
+All rights reserved.
+###
+
+Item       = require '../src/coffee/models/item'
+ItemSlug   = require '../src/coffee/models/item_slug'
+ModVersion = require '../src/coffee/models/mod_version'
+
+########################################################################################################################
+
+modVersion = null
+
+########################################################################################################################
+
+describe 'mod_version.coffee', ->
+
+    beforeEach ->
+        modVersion = new ModVersion modSlug:'test', version:'0.0'
+        modVersion.addItem new Item name:'underscore', group:'punctuation'
+        modVersion.addItem new Item name:'bravo',      group:'letter'
+        modVersion.addItem new Item name:'alpha',      group:'letter'
+        modVersion.addItem new Item name:'one',        group:'number'
+        modVersion.addItem new Item name:'two',        group:'number'
+
+    describe 'constructor', ->
+
+        it 'requires a mod slug', ->
+            expect(-> new ModVersion version:'0.0').to.throw Error, 'attributes.modSlug is required'
+
+        it 'requires a mod version', ->
+            expect(-> new ModVersion modSlug:'test').to.throw Error, 'attributes.version is required'
+
+    describe 'addItem', ->
+
+        it 'refuses to add duplicates', ->
+            modVersion.addItem new Item name:'Wool'
+            expect(-> modVersion.addItem new Item name:'Wool').to.throw Error, 'duplicate item for Wool'
+
+        it 'adds an item indexed by its slug', ->
+            modVersion.addItem new Item name:'Wool'
+            modVersion._items.wool.name.should.equal 'Wool'
+
+        it 'sets the modVersion', ->
+            modVersion.addItem new Item name:'Wool'
+            modVersion._items.wool.modVersion.should.equal modVersion
+
+    describe 'eachGroup', ->
+
+        it 'returns all the groups in order', ->
+            groupNames = []
+            modVersion.eachGroup (groupName)-> groupNames.push groupName
+            groupNames.should.eql ['letter', 'number', 'punctuation']
+
+    describe 'eachItemInGroup', ->
+
+        it 'returns immediately for unknown group', ->
+            slugs = []
+            modVersion.eachItemInGroup 'foobar', (item)-> slugs.push item.slug.qualified
+            slugs.should.eql []
+
+        it 'calls callback for exactly the items in a group in order', ->
+            slugs = []
+            modVersion.eachItemInGroup 'letter', (item)-> slugs.push item.slug.qualified
+            slugs.should.eql ['test__alpha', 'test__bravo']
+
+            slugs = []
+            modVersion.eachItemInGroup 'number', (item)-> slugs.push item.slug.qualified
+            slugs.should.eql ['test__one', 'test__two']
+
+
+    describe 'findItemByName', ->
+
+        it 'locates items by slugified name', ->
+            modVersion.addItem new Item name:'Crafting Table'
+            modVersion.findItemByName('Crafting Table').slug.qualified.should.equal 'test__crafting_table'
+
+    describe 'findRecipes', ->
+
+        beforeEach ->
+            modVersion = new ModVersion modSlug:'test', version:'1.0'
+            modVersion.parse """
+                schema:1
+
+                item: Cake
+                    recipe:; input: Milk, Sugar, Egg, Wheat; pattern: 000 121 333; extras: 3 Bucket
+                    recipe:; input: Milk, Cocoa Beans, Egg, Wheat; pattern: 000 121 333; extras: 3 Bucket
+                item: Bucket
+                    recipe:; input: Iron Ingot; pattern: ... 0.0 .0.
+            """
+
+        it 'finds all recipes which list item as output', ->
+            recipes = modVersion.findRecipes ItemSlug.slugify('test__bucket')
+            (r.output[0].itemSlug.item for r in recipes).sort().should.eql ['bucket', 'cake', 'cake']

test/parser_versions/command_parser_version_base.test.coffee

@@ -0,0 +1,48 @@
+###
+Crafting Guide - command_parser_version_base.test.coffee
+
+Copyright (c) 2015 by Redwood Labs
+All rights reserved.
+###
+
+CommandParserVersionBase = require '../../src/coffee/models/parser_versions/command_parser_version_base'
+
+########################################################################################################################
+
+parser = null
+
+########################################################################################################################
+
+describe 'command_parser_version_base.coffee', ->
+
+    beforeEach -> parser = new CommandParserVersionBase model:{}
+
+    describe '_parseHereDoc', ->
+
+        it 'returns null for non-heredoc lines', ->
+            result = parser._parseHereDoc 'foobar: baz'
+            expect(result[1]).to.be.null
+
+        it 'identifies the right text for a real heredoc', ->
+            parser._lines = ['command: <<-END', 'alpha', 'bravo', 'charlie', 'END', 'command1: arg2']
+            parser._lineNumber = 1
+
+            result = parser._parseHereDoc parser._lines[0]
+            result[0].should.equal 'command: '
+            result[1].should.equal 'alpha\nbravo\ncharlie'
+
+        it 'identifies an empty heredoc', ->
+            parser._lines = ['command: <<-END', 'END']
+            parser._lineNumber = 1
+
+            result = parser._parseHereDoc parser._lines[0]
+            result[0].should.equal 'command: '
+            expect(result[1]).to.be.null
+
+        it 'trims smallest leading whitespace', ->
+            parser._lines = ['command: <<-END', '  alpha', '    bravo', '', '  charlie', 'END', 'command1: arg2']
+            parser._lineNumber = 1
+
+            result = parser._parseHereDoc parser._lines[0]
+            result[0].should.equal 'command: '
+            result[1].should.equal 'alpha\n  bravo\n\ncharlie'

test/parser_versions/mod_version_parser_v1.test.coffee

@@ -0,0 +1,253 @@
+###
+Crafting Guide - mod_version_parser_v1.test.coffee
+
+Copyright (c) 2015 by Redwood Labs
+All rights reserved.
+###
+
+CommandParserVersionBase = require '../../src/coffee/models/parser_versions/command_parser_version_base'
+ItemSlug                 = require '../../src/coffee/models/item_slug'
+ModVersion               = require '../../src/coffee/models/mod_version'
+ModVersionParserV1       = require '../../src/coffee/models/parser_versions/mod_version_parser_v1'
+{Logger}                 = require 'crafting-guide-common'
+
+########################################################################################################################
+
+baseText = modVersion = parser = null
+
+########################################################################################################################
+
+describe 'mod_version_parser_v1.coffee', ->
+
+    beforeEach ->
+        modVersion = new ModVersion modSlug:'test', version:'0.0'
+        parser     = new ModVersionParserV1 model:modVersion
+
+    describe 'Item', ->
+
+        it 'allows multiple recipes', ->
+            recipes = "item: Charlie;
+                recipe:; input:Alpha; pattern:... .0. ...;
+                recipe:; input:Bravo; pattern:... 0.0 ...;"
+            modVersion = parser.parse recipes
+            recipes = modVersion.findRecipes ItemSlug.slugify 'test__charlie'
+            recipes[0].input[0].itemSlug.qualified.should.equal 'alpha'
+            recipes[1].input[0].itemSlug.qualified.should.equal 'bravo'
+
+        describe 'name', ->
+
+            it 'adds the name when present', ->
+                modVersion = parser.parse 'item: Charlie'
+                modVersion._items.charlie.name.should.equal 'Charlie'
+
+            it 'requires a non-empty name', ->
+                func = -> parser.parse 'item: \n'
+                expect(func).to.throw Error, 'cannot be empty'
+
+        describe 'gatherable', ->
+
+            it 'adds "gatherable" when present', ->
+                modVersion = parser.parse 'item: Alpha Bravo; gatherable: yes'
+                modVersion._items.alpha_bravo.isGatherable.should.be.true
+
+            it 'does not allow a duplicate "gatherable" declaration', ->
+                func = -> parser.parse 'item: Alpha Bravo; gatherable: yes; gatherable: yes'
+                expect(func).to.throw Error, 'duplicate'
+
+            it 'requires "gatherable" to be "yes" or "no"', ->
+                func = -> parser.parse 'item: Alpha Bravo; gatherable: true'
+                expect(func).to.throw Error, 'gatherable must be'
+
+            it 'does not allow "gatherable" before "item"', ->
+                func = -> parser.parse 'gatherable: yes; item: Alpha Bravo; gatherable: yes'
+                expect(func).to.throw Error, '"gatherable" before "item"'
+
+    describe 'Recipe', ->
+
+        beforeEach -> baseText = 'item: Charlie; '
+
+        describe 'input', ->
+
+            it 'adds "input" when present', ->
+                logger.doAtLevel 'DEBUG', ->
+                    modVersion = parser.parse baseText + 'recipe:; input:Alpha, Bravo; pattern: ... 010 ...'
+                    slugs = (s.itemSlug.item for s in modVersion.findRecipes(ItemSlug.slugify('test__charlie'))[0].input)
+                    slugs.should.eql ['alpha', 'bravo']
+
+            it 'requires an "input" declaration', ->
+                func = -> parser.parse baseText + 'recipe:; pattern: ... .0. ...'
+                expect(func).to.throw Error, 'the "input" declaration is required'
+
+            it 'does not allow a duplicate "input" declaration', ->
+                func = -> parser.parse baseText + 'recipe:; input:Alpha; pattern:....0....; input:Bravo'
+                expect(func).to.throw Error, 'duplicate declaration of "input"'
+
+            it 'does not allow "input" before "recipe"', ->
+                func = -> parser.parse baseText + 'input:Alpha, Bravo; recipe:; pattern:....0....'
+                expect(func).to.throw Error, 'cannot declare "input" before "recipe"'
+
+            it 'registers slugs for each input name', ->
+                modVersion = parser.parse baseText + 'recipe:; input:Delta, Echo, Foxtrot; pattern:...012...'
+                (s.item for s in modVersion._slugs).should.eql ['charlie', 'delta', 'echo', 'foxtrot']
+
+        describe 'pattern', ->
+
+            it 'adds "pattern" when present', ->
+                modVersion = parser.parse baseText + 'recipe:; input:Alpha, Bravo; pattern:... .0. .1.'
+                modVersion.findRecipes(ItemSlug.slugify('test__charlie'))[0].pattern.should.equal '... .0. .1.'
+
+            it 'requires a "pattern" declaration', ->
+                func = -> parser.parse baseText + 'recipe:; input:Alpha, Bravo'
+                expect(func).to.throw Error, 'the "pattern" declaration is required'
+
+            it 'does not allow a duplicate "pattern" declaration', ->
+                func = -> parser.parse baseText + 'recipe:; input:Alpha, Bravo; pattern:....0..1.; pattern:01.......'
+                expect(func).to.throw Error, 'duplicate declaration of "pattern"'
+
+            it 'requires pattern to be the right length', ->
+                func = -> parser.parse baseText + 'recipe:; input:Alpha; pattern:000'
+                expect(func).to.throw Error, 'a pattern must have'
+
+            it 'requires pattern to only use proper characters', ->
+                func = -> parser.parse baseText + 'recipe:; input:Alpha; pattern:abc def ghi'
+                expect(func).to.throw Error, 'a pattern must have'
+
+            it 'requires pattern to only refer to existing items', ->
+                func = -> parser.parse baseText + 'recipe:; input:Alpha; pattern:... 010 ...'
+                expect(func).to.throw Error, 'there is no input 1 in this recipe'
+
+            it 'requires all items to appear in the pattern', ->
+                func = -> parser.parse baseText + 'recipe:; input:Alpha, Bravo; pattern: 000 0.0 000'
+                expect(func).to.throw Error, 'Bravo is an input'
+
+            it 'computes the input stack sizes from the pattern', ->
+                modVersion = parser.parse baseText + 'recipe:; input:Alpha, Bravo, Delta; pattern:111 .0. 2.2'
+                recipe = modVersion.findRecipes(ItemSlug.slugify('test__charlie'))[0]
+                recipe.input[0].quantity.should.equal 1
+                recipe.input[1].quantity.should.equal 3
+                recipe.input[2].quantity.should.equal 2
+
+            it 'does not allow "pattern" before "recipe"', ->
+                func = -> parser.parse baseText + 'pattern:... .0. ...; recipe:; inputs:Alpha'
+                expect(func).to.throw Error, 'cannot declare "pattern" before "recipe"'
+
+        describe 'quantity', ->
+
+            beforeEach ->
+                baseText = 'item: Charlie; recipe:; input:Alpha; pattern:...0.0...; '
+
+            it 'adds "quantity" when present', ->
+                modVersion = parser.parse baseText + 'quantity: 2'
+                modVersion.findRecipes(ItemSlug.slugify('test__charlie'))[0].output[0].quantity.should.equal 2
+
+            it 'does not allow a duplicate "quantity" declaration', ->
+                func = -> parser.parse baseText + 'quantity:1; quantity:2'
+                expect(func).to.throw Error, 'duplicate declaration of "quantity"'
+
+            it 'requires quantity to be an integer', ->
+                func = -> parser.parse baseText + 'quantity:ten'
+                expect(func).to.throw Error, 'quantity must be an integer'
+
+            it 'assumes a quantity of 1 by default', ->
+                modVersion = parser.parse baseText
+                modVersion.findRecipes(ItemSlug.slugify('test__charlie'))[0].output[0].quantity.should.equal 1
+
+            it 'does not allow "quantity" before recipe', ->
+                func = -> parser.parse 'item:Bravo; quantity:12; recipe:;'
+                expect(func).to.throw Error, 'cannot declare "quantity" before "recipe"'
+
+        describe 'output', ->
+
+            beforeEach ->
+                baseText = 'item: Delta; item:Bravo; recipe:; input:Charlie; pattern:... .0. ...; '
+
+            it 'adds a single item as the default output', ->
+                modVersion = parser.parse baseText
+                stack = modVersion.findRecipes(ItemSlug.slugify('test__bravo'))[0].output[0]
+                stack.itemSlug.qualified.should.equal 'test__bravo'
+                stack.quantity.should.equal 1
+
+            it 'can add multiple extras with quantities', ->
+                modVersion = parser.parse baseText + 'extras:2 Delta, 4 Echo'
+                output = modVersion.findRecipes(ItemSlug.slugify('test__bravo'))[0].output
+                output[0].itemSlug.qualified.should.equal 'test__bravo'
+                output[0].quantity.should.equal 1
+                output[1].itemSlug.qualified.should.equal 'test__delta'
+                output[1].quantity.should.equal 2
+                output[2].itemSlug.qualified.should.equal 'echo'
+                output[2].quantity.should.equal 4
+
+            it 'does not allow "extras" before "recipe"', ->
+                func = -> parser.parse 'item:Bravo; extras:Charlie'
+                expect(func).to.throw Error, 'cannot declare "extras" before "recipe"'
+
+            it 'registers slugs for each output name', ->
+                modVersion = parser.parse baseText + 'extras:Delta, Echo'
+                (s.qualified for s in modVersion._slugs).should.eql [
+                    'test__bravo', 'test__delta', 'charlie', 'echo'
+                ]
+
+            it 'does not allow a duplicate "extras" declaration', ->
+                func = -> parser.parse baseText + 'extras:Echo; extras:Delta'
+                expect(func).to.throw Error, 'duplicate declaration of "extras"'
+
+        describe 'tools', ->
+
+            beforeEach ->
+                baseText = 'item:Bravo; recipe:; input:Charlie; pattern:... .0. ...; '
+
+            it 'can add a single tool', ->
+                modVersion = parser.parse baseText + 'tools: Furnace'
+                modVersion.findRecipes(ItemSlug.slugify('test__bravo'))[0].tools[0].itemSlug.item.should.equal 'furnace'
+
+            it 'can add multiple tools', ->
+                modVersion = parser.parse baseText + 'tools: Crafting Table, Furnace'
+                tools = modVersion.findRecipes(ItemSlug.slugify('test__bravo'))[0].tools
+                tools[0].itemSlug.item.should.equal 'crafting_table'
+                tools[1].itemSlug.item.should.equal 'furnace'
+
+            it 'registers slugs for each tool name', ->
+                modVersion = parser.parse baseText + 'tools: Crafting Table, Furnace'
+                (s.item for s in modVersion._slugs).should.eql ['bravo', 'charlie', 'crafting_table', 'furnace']
+
+            it 'does not allow a duplicate "tools" declaration', ->
+                func = -> parser.parse baseText + 'tools:Crafting Table; tools:Furnace'
+                expect(func).to.throw Error, 'duplicate declaration of "tools"'
+
+    describe "unparsing", ->
+
+        beforeEach ->
+            baseText = """
+                schema: 1
+
+                group: Agriculture
+
+                    item: Apple
+
+                    item: Baked Potato
+                        recipe:
+                            input: Potato, furnace fuel
+                            pattern: .0. ... .1.
+                            tools: Furnace
+
+                group: Functional Blocks
+
+                    item: Furnace
+                        recipe:
+                            input: Cobblestone
+                            pattern: 000 0.0 000
+                            tools: Crafting Table
+
+                update: Iron Ingot
+                    recipe:
+                        input: Iron Dust, furnace fuel
+                        pattern: .0. ... .1.
+                        tools: Furnace
+            """
+
+        it 'can round-trip a data file', ->
+            text     = parser.unparse parser.parse baseText
+            actual   = CommandParserVersionBase.simplify text
+            expected = CommandParserVersionBase.simplify baseText
+
+            actual.should.equal expected

test/recipe.test.coffee

@@ -0,0 +1,86 @@
+###
+Crafting Guide - recipe.test.coffee
+
+Copyright (c) 2015 by Redwood Labs
+All rights reserved.
+###
+
+Item     = require '../src/coffee/models/item'
+ItemSlug = require '../src/coffee/models/item_slug'
+Recipe   = require '../src/coffee/models/recipe'
+Stack    = require '../src/coffee/models/stack'
+
+########################################################################################################################
+
+input = output = pattern = recipe = null
+
+########################################################################################################################
+
+describe 'recipe.coffee', ->
+
+    describe 'constructor', ->
+
+        beforeEach ->
+            input = [
+                new Stack(itemSlug:new ItemSlug('iron_gear')),
+                new Stack(itemSlug:new ItemSlug('gold_ingot'), quantity:4)
+            ]
+            pattern = '.1. 101 .1.'
+
+        it 'requires input', ->
+            expect(-> new Recipe slug:'gold_gear', pattern:pattern).to.throw Error, 'attributes.input is required'
+
+        it 'requires a pattern', ->
+            expect(-> new Recipe slug:'gold_gear', input:input).to.throw Error, 'attributes.pattern is required'
+
+        it 'requires either outputs or a slug', ->
+            f = -> new Recipe input:input, pattern:pattern
+            expect(f).to.throw 'attributes.itemSlug or attributes.output is required'
+
+        it 'creates default output', ->
+            recipe = new Recipe itemSlug:ItemSlug.slugify('gold_gear'), input:input, pattern:pattern
+            recipe.output.length.should.equal 1
+            recipe.output[0].itemSlug.qualified.should.equal 'gold_gear'
+            recipe.output[0].quantity.should.equal 1
+
+        it 'assigns a default slug', ->
+            recipe = new Recipe input:input, pattern:pattern, output:[new Stack itemSlug:ItemSlug.slugify('gold_gear')]
+            recipe.itemSlug.qualified.should.equal 'gold_gear'
+
+    describe 'getItemSlugAt', ->
+
+        beforeEach ->
+            input = [
+                new Stack itemSlug:ItemSlug.slugify('iron_gear')
+                new Stack itemSlug:ItemSlug.slugify('gold_ingot'), quantity:4
+            ]
+            recipe = new Recipe itemSlug:'gold_gear', input:input, pattern:'.1. 101 .1.'
+
+        it 'returns the proper item for an early slot', ->
+            recipe.getItemSlugAt(1).qualified.should.equal 'gold_ingot'
+
+        it 'returns the proper item for a late slot', ->
+            recipe.getItemSlugAt(4).qualified.should.equal 'iron_gear'
+
+        it 'returns null for an invalid slot', ->
+            expect(recipe.getItemSlugAt(12)).to.be.null
+
+    describe '_parsePattern', ->
+
+        beforeEach ->
+            recipe = new Recipe
+                itemSlug:  'oak_wood_planks',
+                input: [new Stack itemSlug:new ItemSlug('oak_wood')],
+                pattern:'... .0. ...'
+
+        it 'normalizes invalid characters', ->
+            recipe._parsePattern('$$0 #() 010').should.equal '..0 ... 010'
+
+        it 'removes extra characters', ->
+            recipe._parsePattern('000 000 000 000').should.equal '000 000 000'
+
+        it 'fills in missing characters', ->
+            recipe._parsePattern('000000').should.equal '000 000 ...'
+
+        it 'fills in spaces', ->
+            recipe._parsePattern('000000000').should.equal '000 000 000'

test/test_helper.coffee

@@ -0,0 +1,26 @@
+###
+# Crafting Guide - test.coffee
+#
+# Copyright (c) 2014-2015 by Redwood Labs
+# All rights reserved.
+###
+
+# Test Set-up ##########################################################################################################
+
+chai = require 'chai'
+chai.use require 'sinon-chai'
+chai.config.includeStack = true
+
+global._        = require 'underscore'
+global.Backbone = require 'backbone'
+global.assert   = chai.assert
+global.expect   = chai.expect
+global.should   = chai.should()
+global.util     = require 'util'
+global.w        = require 'when'
+
+{Logger}      = require 'crafting-guide-common'
+global.logger = new Logger level:Logger.FATAL
+
+require '../src/coffee/polyfill'
+require '../src/coffee/underscore_mixins'