seaweed 0.1.0

data/bin/seaweed

@@ -0,0 +1,55 @@
+#!/usr/bin/env jruby
+require 'rubygems'
+require 'bundler'
+require 'celerity'
+require 'watchr'
+
+require File.expand_path('../../lib/required_files', __FILE__)
+require File.expand_path('../../server/server', __FILE__)
+require 'net/http'
+
+PORT = 4567
+
+app = Rack::Builder.app do
+  run Sinatra::Application
+end
+
+mode = case ARGV.first
+  when 's', 'server'
+    'server'
+  when 't', 'terminal'
+    'terminal'
+  when 'a', 'auto'
+    'auto'
+  else
+    'auto'
+end
+
+if mode == 'server'
+  Rack::Handler.default.run app, :Port => PORT
+else
+  Thread.new do
+    Rack::Handler.default.run app, :Port => PORT
+  end
+
+  begin
+    page = Net::HTTP.get URI.parse("http://localhost:#{PORT}/")
+  rescue Errno::ECONNREFUSED
+    sleep 1
+    retry
+  end
+
+  browser = Celerity::Browser.new
+  browser.goto "http://localhost:#{PORT}/#terminal"
+  puts browser.text
+  
+  if mode == 'auto'
+    script = Watchr::Script.new
+    script.watch(/^(lib|spec)\/.*\.coffee$/) do
+      browser.refresh
+      puts browser.text
+    end
+    controller = Watchr::Controller.new(script, Watchr.handler.new)
+    controller.run
+  end
+end

data/lib/Spec.coffee

@@ -0,0 +1,308 @@
+# Seaweed Coffeescript spec framework
+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()
+  
+  # Executes a test case
+  describe: (title, definition) ->
+    @initializeEnvironment() unless @EnvironmentInitialized
+
+    ul = $('<ul></ul>')
+    switch @Format
+      when 'ul'
+        $('.results').append($('<li>' + title + '</li>').append(ul))
+      when 'terminal'
+        $('.results').append "#{title}<br>"
+        ul.depth = 2
+    
+    @testStack = [{
+      title:    title
+      ul:       ul
+      before:   []
+    }]
+    
+    definition()
+  
+  # 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"
+    switch @Format
+      when 'ul'
+        document.title = summary
+        if @errors.length
+          $('<h3>Errors</h3>').appendTo document.body
+          ul = $('<ul></ul>').addClass('errors').appendTo(document.body)
+          for error in @errors
+            ul.append $('<li>').append($('<span>').html(error.message), ' - ', $('<span>').html(error.title))
+      when 'terminal'
+        $('.results').append "<br>"
+        for error in @errors
+          $('.results').append "&#x1b;[31m#{error.message}&#x1b;[0m #{error.title}<br>"
+        color = if @counts.failed > 0
+          31
+        else if @counts.pending > 0
+          33
+        else
+          32
+        $('.results').append "&#x1b;[1m&#x1b;[#{color}m#{summary}&#x1b;[0m<br>"
+  
+  # Extends the environment with test methods
+  initializeEnvironment: ->
+    @EnvironmentInitialized = true
+    
+    @errors = []
+    @counts = {
+      passed:   0
+      failed:   0
+      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;"]
+  
+  # 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
+    }
+  
+  # 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
+}

data/lib/required_files.rb

@@ -0,0 +1,58 @@
+require 'tsort'
+
+class RequiredFiles < Hash
+  include TSort
+  
+  attr_accessor :paths
+  
+  # Adds a file to required list, and recursively scans and adds all other
+  # files required by this file
+  def add name
+    file_name = full_path name
+    if file_name && !self[name.to_sym]
+      requirements = find_requirements file_name
+      self[name.to_sym] = {
+        :file_name  => file_name,
+        :requires   => requirements
+      }
+      requirements.each { |requirement| add requirement }
+    end
+  end
+
+  # Gets an array of file paths sorted in dependency order
+  def sorted_files
+    tsort.map{ |key| self[key][:file_name] }
+  end
+  
+  private
+    # Searches for file in path with given name and returns full file path,
+    # or nil if not found
+    def full_path name
+      file_path = @paths.find { |path| File.exists? "#{path}/#{name}.coffee" }
+      raise "File not found: #{name}" unless file_path
+      file_path && "#{file_path}/#{name}.coffee"
+    end
+  
+    # Scans a coffeescript file for requirement directives.
+    #
+    # Example requirement directives:
+    #   #require ST
+    #   #require ST/Model/Index
+    def find_requirements name
+      requirements = []
+      File.open name do |file|
+        file.each do |line|
+          if line.match /^#require\s+(\S+)\s*$/
+            requirements << $1
+          end
+        end
+      end
+      requirements
+    end
+  
+    # Callback functions for tsort
+    alias tsort_each_node each_key
+    def tsort_each_child node
+      self[node][:requires].each{ |name| yield name.to_sym }
+    end
+end

data/lib/spec.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env jruby
+require "rubygems"
+require "bundler/setup"
+require "coffee-script"
+require "celerity"
+
+Dir.mkdir 'compiled' unless File.exists? 'compiled'
+raise "Can't create compile directory" unless File.directory? 'compiled'
+
+# Compile coffee scripts
+files = Dir['lib/**/*.coffee', 'spec/**/*.coffee']
+longest_name = files.map(&:length).max
+for file in files
+  begin
+    mtime = File.mtime file
+    
+    outfile = file.sub /^(lib|spec)/, 'compiled'
+    outfile = outfile.sub /\.coffee$/, '.js'
+    
+    next if File.exists?(outfile) && File.mtime(outfile) == mtime
+    
+    dir = outfile.sub /\/[^\/]+$/, ''
+    Dir.mkdir dir unless File.exists? dir
+    File.open outfile, 'w' do |f|
+      f.write CoffeeScript.compile(File.read(file))
+    end
+    File.utime mtime, mtime, outfile
+    puts outfile
+  rescue CoffeeScript::CompilationError => e
+    if e.message.match /^SyntaxError: (.*) on line (\d+)\D*$/
+      puts "\e[31m#{file}:#{$2}".ljust(longest_name + 6) + " #{$1}\e[0m"
+    elsif e.message.match /^Parse error on line (\d+): (.*)$/
+      puts "\e[31m#{file}:#{$1}".ljust(longest_name + 6) + " #{$2}\e[0m"
+    else
+      puts "#{file} - #{e.message}"
+    end
+  end
+end
+
+browser = Celerity::Browser.new
+browser.goto 'http://localhost/~tobico/SeaTurtle/spec/spec.html#terminal'
+puts browser.text