mercury-rails 0.1.0

data/spec/javascripts/mercury/regions/snippetable_spec.js.coffee

@@ -0,0 +1,368 @@
+require '/assets/mercury/mercury.js'
+
+describe "Mercury.Regions.Snippetable", ->
+
+  template 'mercury/regions/snippetable.html'
+
+  beforeEach ->
+    @regionElement = $('#snippetable_region1')
+
+  afterEach ->
+    @region = null
+    delete(@region)
+
+  describe "constructor", ->
+
+    beforeEach ->
+      @buildSpy = spyOn(Mercury.Regions.Snippetable.prototype, 'build').andCallFake(=>)
+      @bindEventsSpy = spyOn(Mercury.Regions.Snippetable.prototype, 'bindEvents').andCallFake(=>)
+      @makeSortableSpy = spyOn(Mercury.Regions.Snippetable.prototype, 'makeSortable').andCallFake(=>)
+
+    it "expects an element, window", ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      expect(@region.element.get(0)).toEqual($('#snippetable_region1').get(0))
+      expect(@region.window).toEqual(window)
+
+    it "accepts options", ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window, {foo: 'something'})
+      expect(@region.options).toEqual({foo: 'something'})
+
+    it "calls build", ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      expect(@buildSpy.callCount).toEqual(1)
+
+    it "calls bindEvents", ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      expect(@bindEventsSpy.callCount).toEqual(1)
+
+    it "makes the snippets sortable", ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      expect(@makeSortableSpy.callCount).toEqual(1)
+
+
+  describe "#build", ->
+
+    beforeEach ->
+      spyOn(Mercury.Regions.Snippetable.prototype, 'bindEvents').andCallFake(=>)
+
+    it "sets the element min-height to 20 if it's min-height is 0 (or not set)", ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      expect($('#snippetable_region1').css('minHeight')).toEqual('20px')
+
+
+  describe "observed events", ->
+
+    beforeEach ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      Mercury.region = @region
+
+    describe "custom event: unfocus:regions", ->
+
+      it "removes the focus class", ->
+        @region.element.addClass('focus')
+        Mercury.trigger('unfocus:regions')
+        expect(@region.element.hasClass('focus')).toEqual(false)
+
+      it "destroys the sortable", ->
+        spy = spyOn($.fn, 'sortable').andCallFake(=>)
+        Mercury.trigger('unfocus:regions')
+        expect(spy.argsForCall[0]).toEqual(['destroy'])
+
+      it "triggers the region:blurred event", ->
+        spy = spyOn(Mercury, 'trigger').andCallThrough()
+        Mercury.trigger('unfocus:regions')
+        expect(spy.callCount).toEqual(2)
+        expect(spy.argsForCall[1]).toEqual(['region:blurred', {region: @region}])
+
+      it "does nothing if previewing", ->
+        @region.previewing = true
+        @region.element.addClass('focus')
+        Mercury.trigger('unfocus:regions')
+        expect(@region.element.hasClass('focus')).toEqual(true)
+
+      it "does nothing if it's not the active region", ->
+        Mercury.region = null
+        @region.element.addClass('focus')
+        Mercury.trigger('unfocus:regions')
+        expect(@region.element.hasClass('focus')).toEqual(true)
+
+    describe "custom event: focus:window", ->
+
+      it "removes the focus class", ->
+        @region.element.addClass('focus')
+        Mercury.trigger('focus:window')
+        expect(@region.element.hasClass('focus')).toEqual(false)
+
+      it "destroys the sortable", ->
+        spy = spyOn($.fn, 'sortable').andCallFake(=>)
+        Mercury.trigger('focus:window')
+        expect(spy.argsForCall[0]).toEqual(['destroy'])
+
+      it "triggers the region:blurred event", ->
+        spy = spyOn(Mercury, 'trigger').andCallThrough()
+        Mercury.trigger('focus:window')
+        expect(spy.callCount).toEqual(2)
+        expect(spy.argsForCall[1]).toEqual(['region:blurred', {region: @region}])
+
+      it "does nothing if previewing", ->
+        @region.previewing = true
+        @region.element.addClass('focus')
+        Mercury.trigger('focus:window')
+        expect(@region.element.hasClass('focus')).toEqual(true)
+
+      it "does nothing if it's not the active region", ->
+        Mercury.region = null
+        @region.element.addClass('focus')
+        Mercury.trigger('focus:window')
+        expect(@region.element.hasClass('focus')).toEqual(true)
+
+    describe "keydown on document (for undo / redo)", ->
+
+      it "calls execCommand with undo on meta+z", ->
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'execCommand')
+        jasmine.simulate.keydown(document, {shiftKey: false, metaKey: true, keyCode: 90})
+        expect(spy.callCount).toEqual(1)
+        expect(spy.argsForCall[0]).toEqual(['undo'])
+
+      it "calls execCommand with redo on shift+meta+z", ->
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'execCommand')
+        jasmine.simulate.keydown(document, {shiftKey: true, metaKey: true, keyCode: 90})
+        expect(spy.callCount).toEqual(1)
+        expect(spy.argsForCall[0]).toEqual(['redo'])
+
+      it "does nothing if previewing", ->
+        @region.previewing = true
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'execCommand')
+        jasmine.simulate.keydown(document, {shiftKey: true, metaKey: true, keyCode: 90})
+        expect(spy.callCount).toEqual(0)
+
+      it "does nothing if it's not the active region", ->
+        Mercury.region = null
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'execCommand')
+        jasmine.simulate.keydown(document, {shiftKey: true, metaKey: true, keyCode: 90})
+        expect(spy.callCount).toEqual(0)
+
+    describe "mouseup", ->
+
+      it "calls focus", ->
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'focus')
+        jasmine.simulate.mouseup(@region.element.get(0))
+        expect(spy.callCount).toEqual(1)
+
+      it "triggers the region:focused event", ->
+        spy = spyOn(Mercury, 'trigger')
+        jasmine.simulate.mouseup(@region.element.get(0))
+        expect(spy.callCount).toEqual(1)
+
+      it "does nothing if previewing", ->
+        @region.previewing = true
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'focus')
+        jasmine.simulate.mouseup(@region.element.get(0))
+        expect(spy.callCount).toEqual(0)
+
+    describe "dragover", ->
+
+      # todo: I'd like to find a nice way to test these things
+      it "prevents the default event", ->
+      it "does nothing if previewing", ->
+
+    describe "drop", ->
+
+      # todo: I'd like to find a nice way to test these things
+      it "calls focus", ->
+      it "prevents the default event", ->
+      it "displays the options for the snippet that was dropped", ->
+      it "does nothing if previewing", ->
+      it "does nothing if there's no active snippet", ->
+
+
+  describe "#focus", ->
+
+    beforeEach ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+
+    it "sets the active mercury region", ->
+      Mercury.region = null
+      @region.focus()
+      expect(Mercury.region).toEqual(@region)
+
+    it "makes the snippets sortable again", ->
+      spy = spyOn(Mercury.Regions.Snippetable.prototype, 'makeSortable')
+      @region.focus()
+      expect(spy.callCount).toEqual(1)
+
+    it "adds the focus class to the element", ->
+      @region.focus()
+      expect($('#snippetable_region1').hasClass('focus')).toEqual(true)
+
+
+  describe "#togglePreview", ->
+
+    beforeEach ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+
+    describe "when not previewing", ->
+
+      it "it destroys the sortable", ->
+        spy = spyOn($.fn, 'sortable').andCallFake(=>)
+        @region.togglePreview()
+        expect(spy.callCount).toEqual(1)
+        expect(spy.argsForCall[0]).toEqual(['destroy'])
+
+      it "removes the focus class", ->
+        @regionElement.addClass('focus')
+        @region.togglePreview()
+        expect($('#snippetable_region1').hasClass('focus')).toEqual(false)
+
+    describe "when previewing", ->
+
+      beforeEach ->
+        @region.previewing = true
+
+      it "makes the snippets sortable again", ->
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'makeSortable')
+        @region.togglePreview()
+        expect(spy.callCount).toEqual(1)
+
+
+  describe "#execCommand", ->
+
+    beforeEach ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      Mercury.Regions.Snippetable.actions['foo'] = ->
+      @handlerSpy = spyOn(Mercury.Regions.Snippetable.actions, 'foo')
+
+    it "calls a handler (from the actions) if one exists", ->
+      @region.execCommand('foo', {value: 'something'})
+      expect(@handlerSpy.callCount).toEqual(1)
+      expect(@handlerSpy.argsForCall[0]).toEqual([{value: 'something'}])
+
+
+  describe "#makeSortable", ->
+
+    beforeEach ->
+      @region = new Mercury.Regions.Snippetable(@regionElement, window)
+      @sortableSpy = spyOn($.fn, 'sortable')
+
+    it "makes the snippets sortable", ->
+      @sortableSpy.andCallFake((arg) => return @region.element if arg == 'destroy' )
+      @region.makeSortable()
+      expect(@sortableSpy.callCount).toEqual(2)
+      expect(@sortableSpy.argsForCall[0]).toEqual(['destroy'])
+      expect(@sortableSpy.argsForCall[1][0]['document']).toEqual(@region.document)
+
+    it "triggers the hide:toolbar event at the end of the dragging", ->
+      spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+      @sortableSpy.andCallFake((arg) => if arg == 'destroy' then return @region.element else arg.beforeStop())
+      @region.makeSortable()
+      expect(spy.callCount).toEqual(1)
+      expect(spy.argsForCall[0]).toEqual(['hide:toolbar', {type: 'snippet', immediately: true}])
+
+    it "pushes to the history after dragging", ->
+      spy = spyOn(Mercury.Regions.Snippetable.prototype, 'pushHistory').andCallFake(=>)
+      spyOn(window, 'setTimeout').andCallFake((callback)=> callback())
+      @sortableSpy.andCallFake((arg) => if arg == 'destroy' then return @region.element else arg.stop())
+      @region.makeSortable()
+      expect(spy.callCount).toEqual(1)
+
+
+
+describe "Mercury.Regions.Snippetable.actions", ->
+
+  template 'mercury/regions/snippetable.html'
+
+  beforeEach ->
+    @region = new Mercury.Regions.Snippetable($('#snippetable_region2'), window)
+    @actions = Mercury.Regions.Snippetable.actions
+
+  describe ".undo", ->
+
+    it "calls undo on the history buffer and sets the content", ->
+      htmlSpy = spyOn(Mercury.Regions.Snippetable.prototype, 'html').andCallFake(=>)
+      historySpy = spyOn(@region.history, 'undo').andCallFake(=> 'history -1')
+      @actions['undo'].call(@region)
+      expect(historySpy.callCount).toEqual(1)
+      expect(htmlSpy.callCount).toEqual(1)
+      expect(htmlSpy.argsForCall[0]).toEqual(['history -1'])
+
+
+  describe ".redo", ->
+
+    it "calls redo on the history buffer and sets the content", ->
+      htmlSpy = spyOn(Mercury.Regions.Snippetable.prototype, 'html').andCallFake(=>)
+      historySpy = spyOn(@region.history, 'redo').andCallFake(=> 'history +1')
+      @actions['redo'].call(@region)
+      expect(historySpy.callCount).toEqual(1)
+      expect(htmlSpy.callCount).toEqual(1)
+      expect(htmlSpy.argsForCall[0]).toEqual(['history +1'])
+
+
+  describe ".insertsnippet", ->
+
+    beforeEach ->
+      Mercury.Snippet.load({
+        'snippet_1': {name: 'example', options: {'foo': 'bar'}},
+        'snippet_2': {name: 'example', options: {'foo': 'bar'}},
+      })
+      spyOn(Mercury.Snippet.prototype, 'loadPreview').andCallFake(=>)
+
+    describe "updating a snippet", ->
+
+      it "finds the snippet by it's identity and replaces it with the new snippet", ->
+        @actions['insertsnippet'].call(@region, {value: Mercury.Snippet.find('snippet_1')})
+        expect($('#snippetable_region2').html()).toContain('class="mercury-snippet"')
+        expect($('#snippetable_region2').html()).toContain('contenteditable="false"')
+        expect($('#snippetable_region2').html()).toContain('data-version="1"')
+        expect($('#snippetable_region2').html()).toContain('data-snippet="snippet_1"')
+        expect($('#snippetable_region2').html()).toContain('[snippet_1]')
+
+      it "pushes to the history after it's been rendered", ->
+        spyOn(Mercury.Snippet.prototype, 'getHTML').andCallFake((x, callback) => callback() if callback)
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'pushHistory').andCallFake(=>)
+        @actions['insertsnippet'].call(@region, {value: Mercury.Snippet.find('snippet_1')})
+        expect(spy.callCount).toEqual(1)
+
+    describe "inserting a snippet", ->
+
+      it "appends the new snippet html to the element", ->
+        @actions['insertsnippet'].call(@region, {value: Mercury.Snippet.find('snippet_2')})
+        expect($('#snippetable_region2 .mercury-snippet').length).toEqual(2)
+
+      it "pushes to the history after it's been rendered", ->
+        spyOn(Mercury.Snippet.prototype, 'getHTML').andCallFake((x, callback) => callback() if callback)
+        spy = spyOn(Mercury.Regions.Snippetable.prototype, 'pushHistory').andCallFake(=>)
+        @actions['insertsnippet'].call(@region, {value: Mercury.Snippet.find('snippet_2')})
+        expect(spy.callCount).toEqual(1)
+
+
+  describe ".editsnippet", ->
+
+    beforeEach ->
+      @region.snippet = $('#snippetable_region2 .mercury-snippet')
+
+    it "finds and displays the options for the given snippet", ->
+      spy = spyOn(Mercury.Snippet.prototype, 'displayOptions')
+      @actions['editsnippet'].call(@region)
+      expect(spy.callCount).toEqual(1)
+
+    it "does nothing if there's no active snippet (eg. hovered over)", ->
+      @region.snippet = null
+      spy = spyOn(Mercury.Snippet.prototype, 'displayOptions')
+      @actions['editsnippet'].call(@region)
+      expect(spy.callCount).toEqual(0)
+
+
+  describe ".removesnippet", ->
+
+    beforeEach ->
+      @region.snippet = $('#snippetable_region2 .mercury-snippet')
+
+    it "removes the snippet if there's an active one", ->
+      @actions['removesnippet'].call(@region)
+      expect($('#snippetable_region2 .mercury-snippet').length).toEqual(0)
+
+    it "triggers the hide:toolbar event", ->
+      spy = spyOn(Mercury, 'trigger').andCallFake(=>)
+      @actions['removesnippet'].call(@region)
+      expect(spy.callCount).toEqual(1)
+      expect(spy.argsForCall[0]).toEqual(['hide:toolbar', {type: 'snippet', immediately: true}])

data/spec/javascripts/mercury/select_spec.js.coffee

@@ -0,0 +1,51 @@
+require '/assets/mercury/mercury.js'
+
+describe "Mercury.Select", ->
+
+  template 'mercury/select.html'
+
+  beforeEach ->
+    $.fx.off = true
+
+  afterEach ->
+    @select = null
+    delete(@select)
+
+  describe "#build", ->
+
+    it "builds an element", ->
+      @select = new Mercury.Select('/evergreen/responses/blank.html', 'foo', {appendTo: '#test', for: $('#button')})
+      html = $('<div>').html(@select.element).html()
+      expect(html).toContain('class="mercury-select mercury-foo-select loading"')
+      expect(html).toContain('style="display:none"')
+
+    it "appends to any element", ->
+      @select = new Mercury.Select('/evergreen/responses/blank.html', 'foo', {appendTo: '#select_container', for: $('#button')})
+      expect($('#select_container .mercury-select').length).toEqual(1)
+
+
+  describe "observed events", ->
+
+    beforeEach ->
+      @select = new Mercury.Select('/evergreen/responses/blank.html', 'foo', {appendTo: '#test', for: $('#button')})
+
+    it "hides", ->
+      @select.element.css({display: 'block'})
+      Mercury.trigger('hide:dialogs')
+      expect(@select.element.css('display')).toEqual('none')
+
+    it "doesn't hide if it's the same dialog", ->
+      @select.element.css({display: 'block'})
+      Mercury.trigger('hide:dialogs', @select)
+      expect(@select.element.css('display')).toEqual('block')
+
+
+  describe "#position", ->
+
+    beforeEach ->
+      @select = new Mercury.Select('/evergreen/responses/blank.html', 'foo', {appendTo: '#test', for: $('#button')})
+
+    it "positions based on it's button", ->
+      @select.element.css({display: 'block'})
+      @select.position(true)
+      expect(@select.element.offset()).toEqual({top: 20, left: 42})

data/spec/javascripts/mercury/snippet_spec.js.coffee

@@ -0,0 +1,246 @@
+require '/assets/mercury/mercury.js'
+
+describe "Mercury.Snippet", ->
+
+  template 'mercury/snippet.html'
+
+  afterEach ->
+    Mercury.Snippet.all = []
+
+  describe "constructor", ->
+
+    beforeEach ->
+      @setOptionsSpy = spyOn(Mercury.Snippet.prototype, 'setOptions').andCallFake(=>)
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+
+    it "expects name and identity", ->
+      expect(@snippet.name).toEqual('foo')
+      expect(@snippet.identity).toEqual('identity')
+
+    it "sets the version", ->
+      expect(@snippet.version).toEqual(0)
+      expect(@snippet.identity).toEqual('identity')
+
+    it "creates a history buffer", ->
+      expect(@snippet.history).toBeDefined()
+
+    it "calls setOptions", ->
+      expect(@setOptionsSpy.callCount).toEqual(1)
+
+
+  describe "#getHTML", ->
+
+    beforeEach ->
+      @loadPreviewSpy = spyOn(Mercury.Snippet.prototype, 'loadPreview').andCallFake(=>)
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+
+    it "builds an element (in whatever context is provided", ->
+      ret = @snippet.getHTML($(document))
+      html = $('<div>').html(ret).html()
+      expect(html).toContain('class="mercury-snippet"')
+      expect(html).toContain('contenteditable="false"')
+      expect(html).toContain('data-snippet="identity"')
+      expect(html).toContain('data-version="1"')
+
+    it "sets the default content to the identity", ->
+      ret = @snippet.getHTML($(document))
+      html = $('<div>').html(ret).html()
+      expect(ret.html()).toEqual('[identity]')
+
+    it "calls loadPreview", ->
+      @snippet.getHTML($(document))
+      expect(@loadPreviewSpy.callCount).toEqual(1)
+
+    it "passes callback method to loadPreview", ->
+      callback = =>
+      @snippet.getHTML($(document), callback)
+      expect(@loadPreviewSpy.argsForCall[0][1]).toEqual(callback)
+
+
+  describe "#getText", ->
+
+    beforeEach ->
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+
+    it "returns an identity string", ->
+      expect(@snippet.getText()).toEqual('[--identity--]')
+
+
+  describe "#loadPreview", ->
+
+    beforeEach ->
+      @ajaxSpy = spyOn($, 'ajax')
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+
+    it "makes an ajax request", ->
+      @ajaxSpy.andCallFake(=>)
+      @snippet.loadPreview()
+      expect(@ajaxSpy.callCount).toEqual(1)
+      expect(@ajaxSpy.argsForCall[0][0]).toEqual("/mercury/snippets/foo/preview")
+      expect(@ajaxSpy.argsForCall[0][1]['data']).toEqual({foo: 'bar'})
+      expect(@ajaxSpy.argsForCall[0][1]['type']).toEqual('POST')
+
+    describe "ajax success", ->
+
+      beforeEach ->
+        @ajaxSpy.andCallFake((url, options) => options.success('data'))
+
+      it "sets the data", ->
+        @snippet.loadPreview($('#snippet'))
+        expect(@snippet.data).toEqual('data')
+
+      it "puts the data into the element", ->
+        @snippet.loadPreview($('#snippet'))
+        expect($('#snippet').html()).toEqual('data')
+
+      it "calls the callback if one was provided", ->
+        callCount = 0
+        callback = => callCount += 1
+        @snippet.loadPreview($('#snippet'), callback)
+        expect(callCount).toEqual(1)
+
+    describe "ajax failure", ->
+
+      beforeEach ->
+        @ajaxSpy.andCallFake((url, options) => options.error())
+
+      it "alerts the error", ->
+        spy = spyOn(window, 'alert').andCallFake(=>)
+        @snippet.loadPreview($('#snippet'))
+        expect(spy.callCount).toEqual(1)
+        expect(spy.argsForCall[0]).toEqual(['Error loading the preview for the foo snippet.'])
+
+
+  describe "#displayOptions", ->
+
+    beforeEach ->
+      @modalSpy = spyOn(Mercury, 'modal').andCallFake(=>)
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+
+    it "sets the global snippet to itself", ->
+      @snippet.displayOptions()
+      expect(Mercury.snippet).toEqual(@snippet)
+
+    it "opens a modal", ->
+      @snippet.displayOptions()
+      expect(@modalSpy.callCount).toEqual(1)
+
+
+  describe "#setOptions", ->
+
+    beforeEach ->
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+
+    it "removes rails form default options that aren't for storing", ->
+      @snippet.setOptions({foo: 'baz', utf8: 'check', authenticity_token: 'auth_token'})
+      expect(@snippet.options).toEqual({foo: 'baz'})
+
+    it "increases the version", ->
+      @snippet.setOptions({foo: 'baz'})
+      expect(@snippet.version).toEqual(2)
+
+    it "pushes the options to the history buffer", ->
+      @snippet.setOptions({foo: 'baz'})
+      expect(@snippet.history.stack.length).toEqual(2)
+
+
+  describe "#setVersion", ->
+
+    beforeEach ->
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+      @snippet.history.stack = [1, 2, {foo: 'baz'}, 4, 5, 6, 7, 8, 9, 10]
+
+    it "sets the version", ->
+      @snippet.setVersion(5)
+      expect(@snippet.version).toEqual(4)
+
+    it "accepts a version (can be a string)", ->
+      @snippet.setVersion('2')
+      expect(@snippet.version).toEqual(1)
+
+    it "pulls the version out of the history buffer", ->
+      @snippet.setVersion(3)
+      expect(@snippet.options).toEqual({foo: 'baz'})
+
+    it "returns true if successful", ->
+      ret = @snippet.setVersion('2')
+      expect(ret).toEqual(true)
+
+    it "returns false if not successful", ->
+      ret = @snippet.setVersion('abc')
+      expect(ret).toEqual(false)
+
+
+  describe "#serialize", ->
+
+    beforeEach ->
+      @snippet = new Mercury.Snippet('foo', 'identity', {foo: 'bar'})
+
+    it "returns an object with name and options", ->
+      ret = @snippet.serialize()
+      expect(ret).toEqual({name: 'foo', options: {foo: 'bar'}})
+
+
+
+describe "Mercury.Snippet class methods", ->
+
+  afterEach ->
+    Mercury.Snippet.all = []
+
+  describe ".displayOptionsFor", ->
+
+    beforeEach ->
+      @modalSpy = spyOn(Mercury, 'modal').andCallFake(=>)
+
+    it "opens a modal with the name in the url", ->
+      Mercury.Snippet.displayOptionsFor('foo')
+      expect(@modalSpy.callCount).toEqual(1)
+      expect(@modalSpy.argsForCall[0]).toEqual(["/mercury/snippets/foo/options", {title: 'Snippet Options', handler: 'insertsnippet'}])
+
+    it "sets the snippet back to nothing", ->
+      Mercury.snippet = 'foo'
+      Mercury.Snippet.displayOptionsFor('foo')
+      expect(Mercury.snippet).toEqual(null)
+
+
+  describe ".create", ->
+
+    beforeEach ->
+      Mercury.Snippet.all = []
+
+    it "creates a new instance of Mercury.Snippet", ->
+      ret = Mercury.Snippet.create('foo', {foo: 'bar'})
+      expect(ret.options).toEqual({foo: 'bar'})
+
+    it "generates an identity and passes it to the instance", ->
+      ret = Mercury.Snippet.create('foo', {foo: 'bar'})
+      expect(ret.identity).toEqual('snippet_0')
+
+    it "pushes into the collection array", ->
+      Mercury.Snippet.create('foo', {foo: 'bar'})
+      expect(Mercury.Snippet.all.length).toEqual(1)
+
+
+  describe ".find", ->
+
+    beforeEach ->
+      Mercury.Snippet.create('foo', {foo: 'bar'})
+
+    it "finds a snippet by identity", ->
+      expect(Mercury.Snippet.find('snippet_0').options).toEqual({foo: 'bar'})
+
+    it "returns null if no snippet was found", ->
+      expect(Mercury.Snippet.find('snippet_x')).toEqual(null)
+
+
+  describe ".load", ->
+
+    beforeEach ->
+      @snippets = {
+        snippet_1: {name: 'foo', options: {foo: 'bar'}}
+        snippet_2: {name: 'bar', options: {baz: 'pizza'}}
+      }
+
+    it "creates a new instance for each item in the collection", ->
+      Mercury.Snippet.load(@snippets)
+      expect(Mercury.Snippet.all.length).toEqual(2)