jazz 0.1.1

data/vendor/jasmine/Rakefile

@@ -0,0 +1,155 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec/jasmine_helper.rb"))
+
+def jasmine_sources
+  sources  = ["src/base.js", "src/util.js", "src/Env.js", "src/Reporter.js", "src/Block.js"]
+  sources += Dir.glob('src/*.js').reject{|f| f == 'src/base.js' || sources.include?(f)}.sort
+  sources
+end
+
+def jasmine_filename(version)
+  "jasmine-#{version['major']}.#{version['minor']}.#{version['build']}.js"
+end
+
+def version_hash
+  JSON.parse(File.new("src/version.json").read);
+end
+
+def start_jasmine_server(jasmine_includes = nil)
+  require File.expand_path(File.join(JasmineHelper.jasmine_root, "contrib/ruby/jasmine_spec_builder"))
+
+  puts "your tests are here:"
+  puts "  http://localhost:8888/run.html"
+
+  Jasmine::SimpleServer.start(
+    8888,
+    lambda { JasmineHelper.specs },
+    JasmineHelper.dir_mappings,
+    :jasmine_files => jasmine_includes)
+end
+
+task :default => 'jasmine:dist'
+
+namespace :jasmine do
+
+  desc 'Prepares for distribution'
+  task :dist => ['jasmine:build', 'jasmine:doc']
+
+  desc 'Check jasmine sources for coding problems'
+  task :lint do
+    passed = true
+    jasmine_sources.each do |src|
+      lines = File.read(src).split(/\n/)
+      lines.each_index do |i|
+        line = lines[i]
+        undefineds = line.scan(/.?undefined/)
+        if undefineds.include?(" undefined") || undefineds.include?("\tundefined")
+          puts "Dangerous undefined at #{src}:#{i}:\n > #{line}"
+          passed = false
+        end
+      end
+    end
+
+    unless passed
+      puts "Lint failed!"
+      exit 1
+    end
+  end
+
+  desc 'Builds lib/jasmine from source'
+  task :build => :lint do
+    puts 'Building Jasmine from source'
+    require 'json'
+
+    sources = jasmine_sources
+    version = version_hash
+
+    old_jasmine_files = Dir.glob('lib/jasmine*.js')
+    old_jasmine_files.each do |file|
+      File.delete(file)
+    end
+
+    jasmine = File.new("lib/#{jasmine_filename version}", 'w')
+
+    sources.each do |source_filename|
+      jasmine.puts(File.read(source_filename))
+    end
+
+    jasmine.puts %{
+jasmine.version_= {
+  "major": #{version['major']},
+  "minor": #{version['minor']},
+  "build": #{version['build']},
+  "revision": #{Time.now.to_i}
+  };
+}
+
+    jasmine.close
+  end
+
+  desc "Build jasmine documentation"
+  task :doc do
+    puts 'Creating Jasmine Documentation'
+    require 'rubygems'
+    #sudo gem install ragaskar-jsdoc_helper
+    require 'jsdoc_helper'
+
+
+    JsdocHelper::Rake::Task.new(:lambda_jsdoc) do |t|
+      t[:files] = jasmine_sources << 'lib/TrivialReporter.js'
+      t[:options] = "-a"
+    end
+    Rake::Task[:lambda_jsdoc].invoke
+  end
+
+
+  desc "Run jasmine tests of source via server"
+  task :server do
+    files = jasmine_sources + ['lib/TrivialReporter.js', 'lib/consolex.js']
+    jasmine_includes = lambda {
+      raw_jasmine_includes = files.collect { |f| File.expand_path(File.join(JasmineHelper.jasmine_root, f)) }
+      Jasmine.cachebust(raw_jasmine_includes).collect {|f| f.sub(JasmineHelper.jasmine_src_dir, "/src").sub(JasmineHelper.jasmine_lib_dir, "/lib") }
+    }
+    start_jasmine_server(jasmine_includes)
+  end
+
+  desc "Build jasmine and run tests via server"
+  task :server_build => 'jasmine:build' do
+
+    start_jasmine_server
+  end
+
+  namespace :test do
+    desc "Run continuous integration tests using a local Selenium runner"
+    task :ci => :'ci:local'
+    namespace :ci do
+
+      task :local => 'jasmine:build' do
+        require "spec"
+        require 'spec/rake/spectask'
+        Spec::Rake::SpecTask.new(:lambda_ci) do |t|
+          t.spec_opts = ["--color", "--format", "specdoc"]
+          t.spec_files = ["spec/jasmine_spec.rb"]
+        end
+        Rake::Task[:lambda_ci].invoke
+      end
+
+      desc "Run continuous integration tests using Sauce Labs 'Selenium in the Cloud'"
+      task :saucelabs => 'jasmine:build' do
+        ENV['SAUCELABS'] = 'true'
+        Rake::Task['jasmine:test:ci:local'].invoke
+      end
+    end
+  end
+
+end
+
+task :test do
+  system "echo jazz " + Dir["spec/**/*[Ss]pec.js"].join(" ")
+  system "jazz " + Dir["spec/**/*[Ss]pec.js"].join(" ")
+end  
+
+task :default => :test
+
+# Local Variables:
+# mode:ruby
+# End:

data/vendor/jasmine/Wakefile

@@ -0,0 +1,68 @@
+begin; require 'wake/event_handlers/em'; rescue LoadError; end
+begin; require 'wake/deps'; rescue LoadError; end
+
+# p "reload"
+
+watch( %r(.*), :modified, lambda { |md| File.directory? md[0] } ) do |md|
+  raise Wake::Refresh
+end
+
+watch( %r(jasmine.wake), :modified ) do |md|
+  raise Wake::Refresh
+end
+
+map_to_test = lambda do |file, event|
+  case file
+  when %r(spec/(.*)([Ss]pec)\.js$)
+    # Run JS spec's using parallel HTML file if it exists
+    prefix = $~[1];
+    prefix.sub! %r(_$), ""
+    files = Dir[prefix+".*htm*"]
+    if html = files.detect { |f| f =~ %r(\.x?html?) }
+      event == :load ? nil : html
+    else 
+      file
+    end
+  else; file
+  end
+end
+
+jazz = lambda do |*args|
+  files = []
+  # boy, clean this up, but call/splat are subtle
+  if Array === args[0]
+    args = args[0][0]
+    files = args.map { |pair| map_to_test.call( pair[0][0], pair[1] ) }
+    files.compact!
+    files.uniq!
+  else
+    (file, event) = *args
+    file = map_to_test.call file, event
+    if file
+      files = [ file ]
+    end
+  end
+  if !files.empty?
+    deps = ""
+    begin deps = "--deps #{db_path}"; rescue; end
+    cmd = "jazz #{deps} #{files.join(" ")}"
+    puts cmd
+    system cmd
+    # puts "exit status: #{$?.exitstatus}" if $?.exited? && $?.exitstatus != 0
+    if  $?.signaled? && $?.termsig == 2
+      Process.kill 2, 0
+    end
+  end
+end
+
+watch( %r((^spec/.*[Ss]pec)\.js$), [ :load, :created, :modified ], nil, :batch => :js ) do |events|
+  jazz.call events
+end
+
+Signal.trap('QUIT') do
+  EM.stop
+end
+
+# Local Variables:
+# mode:ruby
+# End:

data/vendor/jasmine/contrib/ruby/jasmine_runner.rb

@@ -0,0 +1,334 @@
+require 'socket'
+require 'erb'
+require 'json'
+
+module Jasmine
+  def self.root
+    File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+  end
+
+  # this seemingly-over-complex method is necessary to get an open port on at least some of our Macs
+  def self.open_socket_on_unused_port
+    infos = Socket::getaddrinfo("localhost", nil, Socket::AF_UNSPEC, Socket::SOCK_STREAM, 0, Socket::AI_PASSIVE)
+    families = Hash[*infos.collect { |af, *_| af }.uniq.zip([]).flatten]
+
+    return TCPServer.open('0.0.0.0', 0) if families.has_key?('AF_INET')
+    return TCPServer.open('::', 0) if families.has_key?('AF_INET6')
+    return TCPServer.open(0)
+  end
+
+  def self.find_unused_port
+    socket = open_socket_on_unused_port
+    port = socket.addr[1]
+    socket.close
+    port
+  end
+
+  def self.server_is_listening_on(hostname, port)
+    require 'socket'
+    begin
+      socket = TCPSocket.open(hostname, port)
+    rescue Errno::ECONNREFUSED
+      return false
+    end
+    socket.close
+    true
+  end
+
+  def self.wait_for_listener(port, name = "required process", seconds_to_wait = 10)
+    time_out_at = Time.now + seconds_to_wait
+    until server_is_listening_on "localhost", port
+      sleep 0.1
+      puts "Waiting for #{name} on #{port}..."
+      raise "#{name} didn't show up on port #{port} after #{seconds_to_wait} seconds." if Time.now > time_out_at
+    end
+  end
+
+  def self.kill_process_group(process_group_id, signal="TERM")
+    Process.kill signal, -process_group_id # negative pid means kill process group. (see man 2 kill)
+  end
+
+  def self.cachebust(files, root_dir="", replace=nil, replace_with=nil)
+    require 'digest/md5'
+    files.collect do |file_name|
+      real_file_name = replace && replace_with ? file_name.sub(replace, replace_with) : file_name
+      begin
+        digest = Digest::MD5.hexdigest(File.read("#{root_dir}#{real_file_name}"))
+      rescue
+        digest = "MISSING-FILE"
+      end
+      "#{file_name}?cachebust=#{digest}"
+    end
+  end
+
+  class RunAdapter
+    def initialize(spec_files_or_proc, options = {})
+      @spec_files_or_proc = Jasmine.files(spec_files_or_proc) || []
+      @jasmine_files = Jasmine.files(options[:jasmine_files]) || [
+        "/__JASMINE_ROOT__/lib/" + File.basename(Dir.glob("#{Jasmine.root}/lib/jasmine*.js").first),
+        "/__JASMINE_ROOT__/lib/TrivialReporter.js",
+        "/__JASMINE_ROOT__/lib/json2.js",
+        "/__JASMINE_ROOT__/lib/consolex.js",
+      ]
+      @stylesheets = ["/__JASMINE_ROOT__/lib/jasmine.css"] + (Jasmine.files(options[:stylesheets]) || [])
+      @spec_helpers = Jasmine.files(options[:spec_helpers]) || []
+    end
+
+    def call(env)
+      run
+    end
+
+    def run
+      stylesheets = @stylesheets
+      spec_helpers = @spec_helpers
+      spec_files = @spec_files_or_proc
+
+      jasmine_files = @jasmine_files
+      jasmine_files = jasmine_files.call if jasmine_files.respond_to?(:call)
+
+      css_files = @stylesheets
+
+
+      body = ERB.new(File.read(File.join(File.dirname(__FILE__), "run.html"))).result(binding)
+      [
+        200,
+        { 'Content-Type' => 'text/html' },
+        body
+      ]
+    end
+
+
+  end
+
+  class Redirect
+    def initialize(url)
+      @url = url
+    end
+
+    def call(env)
+      [
+        302,
+        { 'Location' => @url },
+        []
+      ]
+    end
+  end
+
+  class JsAlert
+    def call(env)
+      [
+        200,
+        { 'Content-Type' => 'application/javascript' },
+        "document.write('<p>Couldn\\'t load #{env["PATH_INFO"]}!</p>');"
+      ]
+    end
+  end
+
+  class FocusedSuite
+    def initialize(spec_files_or_proc, options)
+      @spec_files_or_proc = Jasmine.files(spec_files_or_proc) || []
+      @options = options
+    end
+
+    def call(env)
+      spec_files = @spec_files_or_proc
+      matching_specs = spec_files.select {|spec_file| spec_file =~ /#{Regexp.escape(env["PATH_INFO"])}/ }.compact
+      if !matching_specs.empty?
+        run_adapter = Jasmine::RunAdapter.new(matching_specs, @options)
+        run_adapter.run
+      else
+        [
+          200,
+          { 'Content-Type' => 'application/javascript' },
+          "document.write('<p>Couldn\\'t find any specs matching #{env["PATH_INFO"]}!</p>');"
+        ]
+      end
+    end
+
+  end
+
+  class SimpleServer
+    def self.start(port, spec_files_or_proc, mappings, options = {})
+      require 'thin'
+      config = {
+        '/__suite__' => Jasmine::FocusedSuite.new(spec_files_or_proc, options),
+        '/run.html' => Jasmine::Redirect.new('/'),
+        '/' => Jasmine::RunAdapter.new(spec_files_or_proc, options)
+      }
+      mappings.each do |from, to|
+        config[from] = Rack::File.new(to)
+      end
+
+      config["/__JASMINE_ROOT__"] = Rack::File.new(Jasmine.root)
+
+      app = Rack::Cascade.new([
+        Rack::URLMap.new(config),
+        JsAlert.new
+      ])
+
+      begin
+        Thin::Server.start('0.0.0.0', port, app)
+      rescue RuntimeError => e
+        raise e unless e.message == 'no acceptor'
+        raise RuntimeError.new("A server is already running on port #{port}")
+      end
+    end
+  end
+
+  class SimpleClient
+    def initialize(selenium_host, selenium_port, selenium_browser_start_command, http_address)
+      require 'selenium/client'
+      @driver = Selenium::Client::Driver.new(
+        selenium_host,
+        selenium_port,
+        selenium_browser_start_command,
+        http_address
+      )
+      @http_address = http_address
+    end
+
+    def tests_have_finished?
+      @driver.get_eval("window.jasmine.getEnv().currentRunner.finished") == "true"
+    end
+
+    def connect
+      @driver.start
+      @driver.open("/")
+    end
+
+    def disconnect
+      @driver.stop
+    end
+
+    def run
+      until tests_have_finished? do
+        sleep 0.1
+      end
+
+      puts @driver.get_eval("window.results()")
+      failed_count = @driver.get_eval("window.jasmine.getEnv().currentRunner.results().failedCount").to_i
+      failed_count == 0
+    end
+
+    def eval_js(script)
+      escaped_script = "'" + script.gsub(/(['\\])/) { '\\' + $1 } + "'"
+
+      result = @driver.get_eval(" try { eval(#{escaped_script}, window); } catch(err) { window.eval(#{escaped_script}); }")
+      JSON.parse("[#{result}]")[0]
+    end
+  end
+
+  class Runner
+    def initialize(selenium_jar_path, spec_files, dir_mappings, options={})
+      @selenium_jar_path = selenium_jar_path
+      @spec_files = spec_files
+      @dir_mappings = dir_mappings
+      @options = options
+
+      @browser = options[:browser] ? options[:browser].delete(:browser) : 'firefox'
+      @selenium_pid = nil
+      @jasmine_server_pid = nil
+      @selenium_host = 'localhost'
+      @jasmine_server_port = Jasmine::find_unused_port
+      @selenium_server_port = Jasmine::find_unused_port
+    end
+
+    def start
+      start_jasmine_server
+      start_selenium_server
+      @client = Jasmine::SimpleClient.new(@selenium_host, @selenium_server_port, "*#{@browser}", "http://localhost:#{@jasmine_server_port}/")
+      @client.connect
+    end
+
+    def stop
+      @client.disconnect
+      stop_selenium_server
+      stop_jasmine_server
+    end
+
+    def start_jasmine_server
+      @jasmine_server_pid = fork do
+        Process.setpgrp
+        Jasmine::SimpleServer.start(@jasmine_server_port, @spec_files, @dir_mappings, @options)
+        exit! 0
+      end
+      puts "jasmine server started.  pid is #{@jasmine_server_pid}"
+      Jasmine::wait_for_listener(@jasmine_server_port, "jasmine server")
+    end
+
+    def start_selenium_server
+      @selenium_pid = fork do
+        Process.setpgrp
+        exec "java -jar #{@selenium_jar_path} -port #{@selenium_server_port} > /dev/null 2>&1"
+      end
+      puts "selenium started.  pid is #{@selenium_pid}"
+      Jasmine::wait_for_listener(@selenium_server_port, "selenium server")
+    end
+
+    def stop_jasmine_server
+      puts "shutting down Jasmine server..."
+      Jasmine::kill_process_group(@jasmine_server_pid) if @jasmine_server_pid
+    end
+
+    def stop_selenium_server
+      puts "shutting down Selenium server..."
+      Jasmine::kill_process_group(@selenium_pid) if @selenium_pid
+    end
+
+    def run
+      begin
+        start
+        puts "servers are listening on their ports -- running the test script..."
+        tests_passed = @client.run
+      ensure
+        stop
+      end
+      return tests_passed
+    end
+
+    def eval_js(script)
+      @client.eval_js(script)
+    end
+  end
+
+  class SauceLabsRunner < Runner
+    def initialize(spec_files, dir_mappings, options={})
+      @spec_files = spec_files
+      @dir_mappings = dir_mappings
+      @options = options
+
+      @browser = options[:browser] ? options[:browser].delete(:browser) : 'firefox'
+      @jasmine_server_pid = nil
+      @jasmine_server_port = Jasmine::find_unused_port
+      @saucelabs_config = SeleniumConfig.new(options[:saucelabs_config], options[:saucelabs_config_file], @jasmine_server_port)
+    end
+
+    def start_selenium_server
+      @sauce_tunnel = SauceTunnel.new(@saucelabs_config)
+    end
+
+    def start
+      start_jasmine_server
+      start_selenium_server
+      @client = Jasmine::SimpleClient.new(@saucelabs_config['selenium_server_address'],
+                  4444,
+                  @saucelabs_config['selenium_browser_key'],
+                  "http://#{@saucelabs_config['application_address']}")
+      @client.connect
+    end
+
+    def stop
+      @client.disconnect
+      @sauce_tunnel.shutdown
+      stop_jasmine_server
+    end
+
+  end
+
+  def self.files(f)
+    result = f
+    result = result.call if result.respond_to?(:call)
+    result
+  end
+
+end