Run and show test results in the editor

keymaps/ava.cson

@@ -0,0 +1,3 @@
+'atom-workspace':
+  'ctrl-alt-a': 'ava:toggle'
+  'ctrl-alt-x': 'ava:run'

lib/main.coffee

@@ -0,0 +1,30 @@
+{CompositeDisposable} = require 'atom'
+Panel = require './panel'
+
+module.exports = TestingForAva =
+  testingForAvaView: null
+  modalPanel: null
+  subscriptions: null
+
+  activate: (state) ->
+    @panel = new Panel(state.testingForAvaViewState)
+    @atomPanel = atom.workspace.addRightPanel(item: @panel, visible: false)
+
+    @subscriptions = new CompositeDisposable
+
+    @subscriptions.add atom.commands.add 'atom-workspace',
+      'ava:toggle': => @toggle()
+      'ava:run': => @panel.run()
+
+  deactivate: ->
+    @subscriptions.dispose()
+    @panel.destroy()
+
+  serialize: ->
+    atomAva: @panel.serialize()
+
+  toggle:  ->
+    if @atomPanel.isVisible()
+      @atomPanel.hide()
+    else
+      @atomPanel.show()

lib/panel.coffee

@@ -0,0 +1,66 @@
+TestRunnerProcess = require './test-runner-process'
+
+module.exports =
+  class Panel
+    constructor: (
+      serializedState,
+      testRunnerProcess = new TestRunnerProcess) ->
+      @testRunnerProcess = testRunnerProcess
+      @renderBase()
+
+    renderBase: ->
+      @element = @createElement('div', 'ava')
+
+      message = @createElement('div', 'message')
+      message.textContent = "AVA test runner"
+      @element.appendChild(message)
+
+      @executing = @createElement('div', 'executing')
+      @executing.textContent = 'Loading'
+      @executing.style.display = 'none'
+      @element.appendChild(@executing)
+
+      @testsContainer = @createElement('div', 'test-container')
+      @element.appendChild(@testsContainer)
+
+    run: ->
+      @toggleExecutingIndicator()
+      @testsContainer.innerHTML = ''
+      editor = atom.workspace.getActiveTextEditor()
+      currentFileName = editor.buffer.file.path
+      @testRunnerProcess.run currentFileName, @renderAssert, @renderFinalReport
+
+    renderAssert: (result) =>
+      newTest = @createElement('div', 'test')
+      status = if result.ok then 'OK' else 'NO'
+      newTest.textContent = "#{status} - #{result.name}"
+      @testsContainer.appendChild newTest
+
+    renderFinalReport: (results) =>
+      @toggleExecutingIndicator()
+      summary = @createElement('div', 'summary')
+      percentage = Math.round((results.pass/results.count)*100)
+      summary.textContent = "#{results.count} total - #{percentage}% passed"
+      @testsContainer.appendChild summary
+
+    createElement: (elementType, cssClass = null) ->
+      element = document.createElement(elementType)
+      if (cssClass?)
+        element.classList.add(cssClass)
+      element
+
+    toggleExecutingIndicator: =>
+      if (@executing.style.display is 'block')
+          @executing.style.display = 'none'
+       else
+          @executing.style.display = 'block'
+
+    # Returns an object that can be retrieved when package is activated
+    serialize: ->
+
+    # Tear down any state and detach
+    destroy: ->
+      @element.remove()
+
+    getElement: ->
+      @element

lib/terminal-command-executor.coffee

@@ -0,0 +1,43 @@
+{Emitter} = require 'event-kit'
+ChildProcess = require 'child_process'
+
+module.exports =
+  class TerminalCommandExecutor
+    constructor: ->
+      @emitter = new Emitter
+
+    run: (command, destinyFolder = null) ->
+      @command = command
+      @destinyFolder = destinyFolder
+
+      spawn = ChildProcess.spawn
+
+      terminal = spawn("bash", ["-l"])
+      terminal.on 'close', @streamClosed
+      terminal.stdout.on 'data', @stdOutDataReceived
+      terminal.stderr.on 'data', @stdErrDataReceived
+
+      terminalCommand = if @destinyFolder then "cd \"#{@destinyFolder}\" && #{@command}\n" else "#{@command}\n"
+
+      console.log "Launching command to terminal: #{terminalCommand}"
+
+      terminal.stdin.write(terminalCommand)
+      terminal.stdin.write("exit\n")
+
+    stdOutDataReceived: (newData) =>
+      @emitter.emit 'onStdOutData', newData.toString()
+
+    stdErrDataReceived: (newData) =>
+      @emitter.emit 'onStdErrData', newData.toString()
+
+    streamClosed: (code) =>
+      @emitter.emit 'onFinishData', code
+
+    onDataReceived: (callback) ->
+      @emitter.on 'onStdOutData', callback
+
+    onDataFinished: (callback) ->
+      @emitter.on 'onFinishData', callback
+
+    destroy: ->
+      @emitter.dispose()

lib/test-runner-process.coffee

@@ -0,0 +1,31 @@
+Parser = require 'tap-parser'
+TerminalCommandExecutor = require './terminal-command-executor'
+
+module.exports =
+  class TestRunnerProcess
+    constructor: (executor = new TerminalCommandExecutor) ->
+      @terminalCommandExecutor = executor
+      @terminalCommandExecutor.onDataReceived (data) => @addAvaOutput(data)
+      @terminalCommandExecutor.onDataFinished => @endAvaOutput()
+
+    run: (filePath, assertCallback, completeCallback) ->
+      @parser = @getParser()
+      @parser.on('assert', assertCallback)
+      @parser.on('complete', completeCallback)
+
+      #TODO: Fix parsing of folders and files
+      folder = filePath.substring(0, filePath.lastIndexOf("/") + 1);
+      file = filePath.split("/").pop()
+
+      command = "ava #{file} --tap"
+
+      @terminalCommandExecutor.run(command, folder)
+
+    addAvaOutput: (data) ->
+      @parser.write(data)
+
+    endAvaOutput: ->
+      @parser.end()
+
+    getParser: ->
+      Parser()

package.json

@@ -2,6 +2,7 @@
   "name": "ava",
   "version": "0.2.0",
   "description": "Snippets for AVA",
+  "main": "./lib/main",
   "license": "MIT",
   "repository": "sindresorhus/atom-ava",
   "private": true,
@@ -28,13 +29,20 @@
   "scripts": {
     "test": "xo"
   },
+  "activationCommands": {
+    "atom-workspace": "ava:toggle"
+  },
   "keywords": [
     "snippets",
     "test",
     "runner",
     "ava",
     "mocha"
   ],
+  "dependencies": {
+    "event-kit": "^1.1.0",
+    "tap-parser": ">=v1.2.2"
+  },
   "devDependencies": {
     "xo": "*"
   },

spec/fake-spawn.coffee

@@ -0,0 +1,31 @@
+module.exports =
+  class FakeSpawn
+    self = []
+    constructor: ->
+      self = @
+      @commandsReceived = []
+
+    on: (event, callback) ->
+      @mainCallBack = callback
+
+    emulateClose: ->
+      @mainCallBack(0)
+
+    stdout: {
+      write: (data) ->
+        @stdOutCallBack data
+      on: (event, callback) ->
+        @stdOutCallBack = callback
+    }
+
+    stderr: {
+      write: (data) ->
+        @stdErrCallBack data
+      on: (event, callback) ->
+        @stdErrCallBack = callback
+    }
+
+    stdin: {
+      write: (command) =>
+        self.commandsReceived.push command
+    }

spec/main-spec.coffee

@@ -0,0 +1,28 @@
+Main = require '../lib/main'
+
+describe "TestingForAva", ->
+  packageName = 'ava'
+  mainSelector = '.ava'
+  toggleCommand = 'ava:toggle'
+  [workspaceElement, activationPromise] = []
+
+  beforeEach ->
+    workspaceElement = atom.views.getView(atom.workspace)
+    activationPromise = atom.packages.activatePackage(packageName)
+
+  describe "when the ava:toggle event is triggered", ->
+    it "hides and shows the view", ->
+      jasmine.attachToDOM(workspaceElement)
+
+      expect(workspaceElement.querySelector(mainSelector)).not.toExist()
+
+      atom.commands.dispatch workspaceElement, toggleCommand
+
+      waitsForPromise ->
+        activationPromise
+
+      runs ->
+        mainElement = workspaceElement.querySelector(mainSelector)
+        expect(mainElement).toBeVisible()
+        atom.commands.dispatch workspaceElement, toggleCommand
+        expect(mainElement).not.toBeVisible()

spec/terminal-command-executor-spec.coffee

@@ -0,0 +1,38 @@
+TerminalCommandExecutor = require '../lib/terminal-command-executor'
+ChildProcess = require 'child_process'
+FakeSpawn = require './fake-spawn'
+
+describe 'TerminalCommandExecutor', ->
+  [executor, fake, exec, stdOutData, exitCode] = {}
+
+  beforeEach ->
+    stdOutData = ''
+    exitCode = -1
+    fake = new FakeSpawn
+    executor = new TerminalCommandExecutor
+    spyOn(ChildProcess, 'spawn').andReturn(fake)
+
+  it 'can be created', ->
+    expect(executor).not.toBeNull()
+
+  it 'writes the command and exits if not destination folder is provided', ->
+    executor.run 'command'
+    expect(fake.commandsReceived[0]).toBe('command\n')
+    expect(fake.commandsReceived[1]).toBe('exit\n')
+
+  it 'writes the folder, command and exits if folder is provided', ->
+    executor.run 'command', 'dir'
+    expect(fake.commandsReceived[0]).toBe('cd "dir" && command\n')
+    expect(fake.commandsReceived[1]).toBe('exit\n')
+
+  it 'calls the callback when new data appears in stdout', ->
+    executor.run 'command'
+    executor.onDataReceived (data) -> stdOutData = data
+    fake.stdout.write('some data')
+    expect(stdOutData).toBe('some data')
+
+  it 'calls the callback when the stream is closed', ->
+    executor.run 'command'
+    executor.onDataFinished (code) -> exitCode = code
+    fake.emulateClose()
+    expect(exitCode).toBe(0)

spec/test-runner-process-spec.coffee

@@ -0,0 +1,36 @@
+TestRunnerProcess = require '../lib/test-runner-process'
+TerminalCommandExecutor = require '../lib/terminal-command-executor'
+
+describe 'TestRunnerProcess', ->
+  [runner, executor, parser] = {}
+
+  beforeEach ->
+    executor = new TerminalCommandExecutor
+    parser = ((completeCallBack) ->
+      on: (eventName, callBack) ->
+      write: ->
+      end: () ->)()
+
+    runner = new TestRunnerProcess(executor)
+    spyOn(runner, 'getParser').andReturn(parser)
+
+  it 'can be created', ->
+    expect(runner).not.toBeNull()
+
+  it 'runs the executor with the appropriate parameters', ->
+    spyOn(atom.project, 'getPaths').andReturn(['path'])
+    spyOn(executor, 'run')
+    runner.run('/somefolder/filename')
+    expect(executor.run).toHaveBeenCalledWith('ava filename --tap', '/somefolder/')
+
+  it 'redirects the output for the parser when is received', ->
+    spyOn(parser, 'write')
+    runner.run('/somefolder/filename')
+    executor.stdOutDataReceived 'newdata'
+    expect(parser.write).toHaveBeenCalledWith('newdata')
+
+  it 'closes the parser stream when the output is over', ->
+    spyOn(parser, 'end')
+    runner.run('/somefolder/filename')
+    executor.streamClosed 0
+    expect(parser.end).toHaveBeenCalled()

styles/ava.less

@@ -0,0 +1,11 @@
+@import "ui-variables";
+
+.ava {
+  padding: 30px;
+  font-size: 15px;
+
+  .message { padding-bottom: 10px; }
+  .summary { font-size: 12px; padding-top: 10px; }
+  .test { font-size: 11px; font-weight: bold; }
+  .executing { font-size: 12px; font-weight: bold; padding-bottom: 10px;}
+}