seaweed 0.1.1 → 0.1.2

data/lib/Spec.coffee

@@ -1,17 +1,13 @@
+#= require Spec/ObjectExtensions
+#= require Spec/WindowExtensions
+
 # Seaweed Coffeescript spec framework
-window.Spec = {
+
+window.Spec ||= {}
+$.extend window.Spec, {
   EnvironmentInitialized: false
-  
-  # Adds   indentation to a string
-  Pad: (string, times) ->
-    for i in [1..times]
-      string = ' ' + string
-    string
-  
-  # Escapes text for HTML
-  Escape: (string) ->
-    $('<div/>').text(String(string)).html()
-  
+  _extended: []
+
   # Executes a test case
   describe: (title, definition) ->
     @initializeEnvironment() unless @EnvironmentInitialized
@@ -32,6 +28,50 @@ window.Spec = {
     
     definition()
   
+  # Tries to format definition source code as readable test description
+  descriptionize: (definition) ->
+    # Get function source code
+    definition = String definition
+    
+    # Remove function boilerplate from beginning
+    definition = definition.replace(/^\s*function\s*\([^\)]*\)\s*\{\s*(return\s*)?/, '')
+    
+    # Remove function boilerplate from end
+    definition = definition.replace(/\s*;\s*\}\s*$/, '')
+    
+    # Replace symbols with whitespace
+    definition = definition.replace(/[\s\(\)_\-\.'"]+/g, ' ')
+    
+    # Split camelCased terms into seperate words
+    definition = definition.replace(/([a-z])([A-Z])/g, (s, a, b) -> "#{a} #{b.toLowerCase()}")
+    
+    definition
+  
+  # Escapes text for HTML
+  escape: (string) ->
+    $('<div/>').text(String(string)).html()
+  
+  # Extends a one or more classes with test methods
+  extend: () ->
+    for klass in arguments
+      @_extended.push klass
+      $.extend klass, @ObjectExtensions
+      $.extend klass.prototype, @ObjectExtensions if klass.prototype
+  
+  # Fails test, with an error message
+  fail: (message, location) ->
+    @passed = false
+    @error = message
+    titles = []
+    for item in @testStack
+      titles.push item.title
+    titles.push @testTitle
+    @errors.push {
+      title:    titles.join ' '
+      message:  message
+      location: location
+    }
+  
   # Displays a summary of error rate at the end of testing
   finalize: ->
     summary = "#{@counts.passed} passed, #{@counts.failed} failed, #{@counts.pending} pending, #{@counts.total} total"
@@ -40,9 +80,12 @@ window.Spec = {
         document.title = summary
         if @errors.length
           $('<h3>Errors</h3>').appendTo document.body
-          ul = $('<ul></ul>').addClass('errors').appendTo(document.body)
+
+          html = ['<table class="errors"><thead><tr><th>Error</th><th>Location</th><th>Test</th></tr></thead><tbody>']
           for error in @errors
-            ul.append $('<li>').append($('<span>').html(error.message), ' - ', $('<span>').html(error.title))
+            html.push '<tr><td>', error.message, '</td><td>', error.location, '</td><td>', error.title, '</td></tr>'
+          html.push '</tbody></table>'
+          $(document.body).append html.join('')
       when 'terminal'
         $('.results').append "<br>"
         for error in @errors
@@ -55,10 +98,25 @@ window.Spec = {
           32
         $('.results').append "&#x1b;[1m&#x1b;[#{color}m#{summary}&#x1b;[0m<br>"
   
+  # Finds a matcher specified by a string, or passes through a matcher
+  # specified directly.
+  findMatcher: (value) ->
+    if typeof value is 'string'
+      if found = value.match(/^be([A-Z]\w*)$/)
+        beAttribute found[1].replace(/^[A-Z]/, (s) -> s.toLowerCase())
+      else if window[value]
+        window[value]
+      else
+        null
+    else
+      value
+  
   # Extends the environment with test methods
   initializeEnvironment: ->
     @EnvironmentInitialized = true
-    
+
+    $.extend window, @WindowExtensions
+
     @errors = []
     @counts = {
       passed:   0
@@ -66,243 +124,73 @@ window.Spec = {
       pending:  0
       total:    0
     }
-    
+
     @Format = 'ul'
     @Format = 'terminal' if location.hash == '#terminal'
-    
+
     # Add results display element to the page
     switch @Format
       when 'ul'
         $('body').append('<ul class="results"></ul>')
       when 'terminal'
         $('body').append('<div class="results"></div>')
-    
-    # Tests for a positive match
-    Object.prototype.should = (matcher) ->
-      result = matcher(this)
-      Spec.fail "expected #{result[1]}" unless result[0]
-
-    # Tests for a negative match
-    Object.prototype.shouldNot = (matcher) ->
-      result = matcher(this)
-      Spec.fail "expected not #{result[1]}" if result[0]
-    
-    # Sets up an expectation
-    window.expectation = (message) ->
-      exp = {
-        message:      message
-        meet:         -> @met++
-        met:          0
-        desired:      1
-        twice:        ->
-          @desired = 2
-          this
-        exactly:      (times) ->
-          @desired = times
-          {times: this}
-        timesString:  (times) ->
-          switch times
-            when 0
-              'not at all'
-            when 1
-              'once'
-            when 2
-              'twice'
-            else
-              "#{times} times"
-        check:        ->
-          if @met != @desired
-            Spec.fail "expected #{message} #{@timesString @desired}, actually received #{@timesString @met}"
-      }
-      Spec.expectations.push exp
-      exp
-    
-    # Creates a stub method with an expectation
-    Object.prototype.shouldReceive = (name) ->
-      object = this
-
-      received = expectation "to receive &ldquo;#{name}&rdquo;"
-
-      passthrough = object[name]
-      object[name] = -> received.meet()
-
-      received.with = (expectArgs...) ->
-        object[name] = (args...) ->
-          received.meet()
-          correct = true
-          correct = false if expectArgs.length != args.length
-          if correct
-            for i in [0..args.length]
-              correct = false unless String(expectArgs[i]) == String(args[i])
-          unless correct
-            Spec.fail "expected ##{name} to be called with arguments &ldquo;#{expectArgs.join ', '}&rdquo;, actual arguments: &ldquo;#{args.join ', '}&rdquo;"
-        received
-
-      received.andReturn = (returnValue) ->
-        fn = object[name]
-        object[name] = ->
-          fn.apply this, arguments
-          returnValue
-        received
-      
-      received.andPassthrough = ->
-        fn = object[name]
-        object[name] = ->
-          fn.apply this, arguments
-          passthrough.apply this, arguments
-        received
-
-      received
-    
-    # Creates a stub method, with an expectation of no calls
-    Object.prototype.shouldNotReceive = (name) ->
-      @shouldReceive(name).exactly(0).times
-    
-    # Allows an assertion on a non-object value
-    window.expect = (object) ->
-      {
-        to: (matcher) ->
-          result = matcher(object)
-          Spec.fail "expected #{result[1]}" unless result[0]
-        notTo: (matcher) ->
-          result = matcher(object)
-          Spec.fail "expected not #{result[1]}" if result[0]
-      }
-    
-    # Adds a setup step to the current test case
-    window.beforeEach = (action) ->
-      test = Spec.testStack[Spec.testStack.length - 1]
-      test.before.push action
-    
-    # Prepares a sub-test of the current test case
-    window.describe = window.context = (title, definition) ->
-      parent = Spec.testStack[Spec.testStack.length - 1]
-    
-      ul = $('<ul></ul>')
-      switch Spec.Format
-        when 'ul'
-          parent.ul.append($('<li>' + title + '</li>').append(ul))
-        when 'terminal'
-          $('.results').append(Spec.Pad(title, parent.ul.depth) + "<br>")
-          ul.depth = parent.ul.depth + 2
-    
-      Spec.testStack.push {
-        title:    title
-        ul:       ul
-        before:   []
-      }
-      definition()
-      Spec.testStack.pop()
-
-    # Creates a specificaition
-    window.it = (title, definition) ->
-      test = Spec.testStack[Spec.testStack.length - 1]
-      status = if definition?
-        env = {sandbox: $('<div/>').appendTo document.body}
-        for aTest in Spec.testStack
-          for action in aTest.before
-            action.call env
-      
-        Spec.expectations = []
-        Spec.testTitle = title
-      
-        window.onerror = (message) ->
-          Spec.fail "Error: #{message}"
-      
-        Spec.passed = true
-        try
-          definition.call env
-        catch e
-          Spec.fail 'Error: ' + e
-        
-        for expectation in Spec.expectations
-          expectation.check()
-      
-        delete Spec.expectations
-        delete Spec.testTitle
-        delete window.onerror
-        
-        env.sandbox.empty().remove()
-        
-        if Spec.passed then "passed"; else "failed"
-      else
-        "pending"
 
-      switch Spec.Format
-        when 'ul'
-          li = $('<li>' + title + '</li>')
-          li.addClass status
-
-          test.ul.append li
-        when 'terminal'
-          s = title
-          color = switch status
-            when 'passed' then 32
-            when 'failed' then 31
-            when 'pending' then 33
-          $('.results').append Spec.Pad("&#x1b;[#{color}m#{s}&#x1b;[0m<br>", test.ul.depth)
-      
-      Spec.counts[status]++
-      Spec.counts.total++
-    
-    # Tests if matched value is a function
-    window.beAFunction = (value) ->
-      [typeof value is 'function', "to have type &ldquo;function&rdquo;, actual &ldquo;#{typeof value}&rdquo;"]
-    
-    # Tests if matched value === expected value
-    window.be = (expected) ->
-      (value) ->
-        [value is expected, "to be &ldquo;#{Spec.Escape expected}&rdquo;, actual &ldquo;#{Spec.Escape value}&rdquo;"]
-    
-    # Tests if matched value is boolean true
-    window.beTrue = (value) ->
-      [String(value) == 'true', "to be true, got &ldquo;#{Spec.Escape value}&rdquo;"]
-    
-    # Tests if matched value is boolean false
-    window.beFalse = (value) ->
-      [String(value) == 'false', "to be false, got &ldquo;#{Spec.Escape value}&rdquo;"]
-    
-    # Tests if matched value is an instance of class
-    window.beAnInstanceOf = (klass) ->
-      (value) ->
-        [value instanceof klass, "to be an instance of &ldquo;#{klass}&rdquo;"]
-    
-    # Tests if matched value == expected value
-    window.equal = (expected) ->
-      (value) ->
-        [String(value) == String(expected), "to equal &ldquo;#{Spec.Escape expected}&rdquo;, actual &ldquo;#{Spec.Escape value}&rdquo;"]
+    @extend Array, Boolean, Date, Element, Function, jQuery, Number, RegExp,
+      SpecObject, String
   
-  # Fails test, with an error message
-  fail: (message) ->
-    @passed = false
-    @error = message
-    titles = []
-    for item in @testStack
-      titles.push item.title
-    titles.push @testTitle
-    @errors.push {
-      title:    titles.join ' '
-      message:  message
-    }
+  # Returns an HTML representation of any kind of object
+  inspect: (object) ->
+    if object instanceof Array
+      s = '['
+      first = true
+      for item in object
+        if first
+          first = false
+        else
+          first += ', '
+        s += '&ldquo;' + @escape(String(item)) + '&rdquo;'
+      s + ']'
+    else if object is null
+      'null'
+    else if object is undefined
+      'undefined'
+    else if object is true
+      'true'
+    else if object is false
+      'false'
+    else if typeof object == 'object'
+      s = "{"
+      first = true
+      for key of object
+        # Access hasOwnProperty through Object.prototype to work around bug
+        # in IE6/7/8 when calling hasOwnProperty on a DOM element
+        if Object.prototype.hasOwnProperty.call(object, key)
+          if first
+            first = false
+          else
+            s += ", "
+          s += @escape(key) + ': &ldquo;' + @escape(String(object[key])) + '&rdquo;'
+      s + "}"
+    else
+      "&ldquo;#{@escape(object)}&rdquo;"
   
+  # Adds &nbsp; indentation to a string
+  pad: (string, times) ->
+    for i in [1..times]
+      string = '&nbsp;' + string
+    string
+    
   # Cleans test environment initialized with #initializeEnvironment
   uninitializeEnvironment: ->
     @EnvironmentInitialized = false
     
-    delete Object.prototype.should
-    delete Object.prototype.shouldNot
-    delete window.expectation
-    delete Object.prototype.shouldReceive
-    delete Object.prototype.shouldNotReceive
-    delete window.expect
-    delete window.beforeEach
-    delete window.describe
-    delete window.context
-    delete window.it
-    delete window.beAFunction
-    delete window.be
-    delete window.beTrue
-    delete window.beFalse
-    delete window.beAnInstanceOf
-    delete window.equal
+    for klass in @_extended
+      for key of @ObjectExtensions
+        delete klass[key]
+        delete klass.prototype[key] if klass.prototype
+    
+    @_extended.length = 0
+    
+    for key of @WindowExtensions
+      delete window[key]
 }

data/lib/seaweed/runner.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+require File.expand_path(File.dirname(__FILE__) + '/../seaweed')
+
+module Seaweed
+  class Runner
+    def initialize mode, options={}, parser=nil
+      Seaweed.load_configuration
+      
+      Seaweed.port = options[:port] if options[:port]
+      
+      if options[:version]
+        puts "Seaweed Version #{Seaweed::VERSION}"
+      else      
+        case mode
+          when 's', 'server'
+            Seaweed.start_server
+          when 't', 'terminal'
+            Seaweed.spawn_server
+            Seaweed.run_suite
+          when 'a', 'auto'
+            Seaweed.spawn_server
+            Seaweed.run_suite
+            Seaweed.watch_for_changes
+          else
+            puts parser || "Unknown mode “#{mode}”"
+        end
+      end
+    end
+  end
+end

data/lib/seaweed/server.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require 'sinatra'
+require 'slim'
+require 'coffee-script'
+require File.expand_path(File.dirname(__FILE__) + '/../seaweed')
+
+module Seaweed
+  class Server < Sinatra::Application
+    # Configure paths
+    set :public_folder,   ROOT + '/public'
+    set :views,           ROOT + '/views'
+
+    # Configure slim for prettier code formatting
+    Slim::Engine.set_default_options :pretty => true
+
+    # Hide redundant log messages
+    disable :logging
+    
+    # Processes request for page index
+    get "/" do
+      # Fetch list of all specification files in specs path
+      @scripts = []
+      Seaweed.specs.each do |path|
+        Dir["#{Seaweed::PROJECT_ROOT}/#{path}/**/*.spec.coffee"].each do |file|
+          @scripts << $1 if file.match Regexp.new("^#{Regexp.escape Seaweed::PROJECT_ROOT}\\/#{Regexp.escape path}\\/(.*).coffee$")
+        end
+      end
+      
+      render :slim, :index
+    end
+  end
+end

data/lib/seaweed/version.rb

@@ -0,0 +1,3 @@
+module Seaweed
+  VERSION = "0.1.2"
+end

data/lib/seaweed.rb

@@ -0,0 +1,121 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'sprockets'
+require 'net/http'
+require 'rack'
+require 'yaml'
+require 'seaweed/version'
+
+module Seaweed
+  ROOT            = File.expand_path File.join(File.dirname(__FILE__), '..')
+  PROJECT_ROOT    = File.expand_path "."
+  
+  CONFIG_PATHS    = [
+    File.join(PROJECT_ROOT, 'seaweed.yml'),
+    File.join(PROJECT_ROOT, 'config', 'seaweed.yml')
+  ]
+  
+  @configuration  = {}
+  
+  def self.load_configuration
+    # Set configuration defaults
+    @configuration['port']        = 4567
+    @configuration['libs']    = ['lib']
+    @configuration['specs']   = ['spec']
+    
+    # Load custom configuration file
+    CONFIG_PATHS.each do |path|
+      if File.exists? path
+        @configuration.merge! YAML.load(File.read(path))
+        puts "Loaded configuration from “#{path}”"
+      end
+    end
+  end
+
+  def self.port
+    @configuration['port']
+  end
+
+  def self.port= value
+    @configuration['port'] = value
+  end
+  
+  def self.root_url
+    "http://localhost:#{port}/"
+  end
+  
+  def self.libs
+    @configuration['libs']
+  end
+  
+  def self.specs
+    @configuration['specs']
+  end
+  
+  def self.all_paths
+    libs + specs
+  end
+  
+  # Prepares a Sprockets::Environment object to serve coffeescript assets
+  def self.sprockets_environment
+    @environment ||= Sprockets::Environment.new.tap do |environment|
+      environment.append_path File.join(Seaweed::ROOT, 'lib')
+      all_paths.each do |path|
+        environment.append_path path
+      end
+    end
+  end
+  
+  def self.start_server
+    app = Rack::Builder.app do
+      map '/assets' do
+        run Seaweed.sprockets_environment
+      end
+      
+      map '/' do
+        run Seaweed::Server
+      end
+    end
+    Rack::Handler.default.run app, :Port => port
+  end
+  
+  def self.spawn_server
+    # Start server in its own thread
+    Thread.new &start_server
+    
+    # Keep trying to connect to server until we succeed
+    begin
+      page = Net::HTTP.get URI.parse(root_url)
+    rescue Errno::ECONNREFUSED
+      sleep 1
+      retry
+    end
+  end
+  
+  def self.run_suite
+    require 'celerity'
+    
+    if @browser
+      @browser.refresh
+    else
+      @browser = Celerity::Browser.new
+      @browser.goto "#{root_url}#terminal"
+    end
+    puts @browser.text
+  end
+  
+  def self.watch_for_changes
+    require 'watchr'
+    
+    # Build a regexp to match .coffee files in any project paths
+    path_matcher = Regexp.new('^(' + all_paths.map{ |s| Regexp.escape s}.join('|') + ')\/.*\.coffee$')
+    
+    script = Watchr::Script.new
+    script.watch(path_matcher) { run_suite }
+    controller = Watchr::Controller.new(script, Watchr.handler.new)
+    controller.run
+  end
+end
+
+require File.expand_path(File.dirname(__FILE__) + '/seaweed/server')

data/public/ie.js

@@ -0,0 +1,5 @@
+if(typeof String.prototype.trim !== 'function') {
+  String.prototype.trim = function() {
+    return this.replace(/^\s+|\s+$/g, ''); 
+  }
+}