274 lines
6.5 KiB
Ruby
274 lines
6.5 KiB
Ruby
require 'fileutils'
|
|
|
|
require 'coffee-script'
|
|
require 'rainbow'
|
|
|
|
require 'yaml'
|
|
require 'erb'
|
|
require 'sprockets'
|
|
|
|
module Jasmine
|
|
module Headless
|
|
class IndexHandler
|
|
class << self
|
|
attr_accessor :index
|
|
end
|
|
|
|
def initialize(app)
|
|
@app = app
|
|
end
|
|
|
|
def call(env)
|
|
if env['PATH_INFO'] == '/'
|
|
return [ 302, { 'Location' => self.class.index }, [ 'Redirecting...' ] ]
|
|
end
|
|
|
|
@app.call(env)
|
|
end
|
|
end
|
|
|
|
class Runner
|
|
JASMINE_DEFAULTS = {
|
|
'spec_files' => [ '**/*[sS]pec.js' ],
|
|
'helpers' => [ 'helpers/**/*.js' ],
|
|
'spec_dir' => 'spec/javascripts',
|
|
'src_dir' => nil,
|
|
'stylesheets' => [],
|
|
'src_files' => [],
|
|
'backtrace' => []
|
|
}
|
|
|
|
RUNNER_DIR = File.expand_path('../../../../ext/jasmine-webkit-specrunner', __FILE__)
|
|
RUNNER = File.join(RUNNER_DIR, 'jasmine-webkit-specrunner')
|
|
|
|
attr_reader :options
|
|
|
|
def self.run(options = {})
|
|
new(options).run
|
|
end
|
|
|
|
def self.server_port
|
|
return @server_port if @server_port
|
|
|
|
require 'socket'
|
|
|
|
count = 100
|
|
begin
|
|
port = select_server_port
|
|
|
|
socket = TCPSocket.new(server_interface, port)
|
|
socket.close
|
|
|
|
count -= 1
|
|
|
|
raise "Could not create server port after 100 attempts!" if count == 0
|
|
rescue Errno::ECONNREFUSED
|
|
@server_port = port
|
|
|
|
break
|
|
ensure
|
|
begin
|
|
socket.close if socket
|
|
rescue IOError
|
|
end
|
|
end while true
|
|
|
|
@server_port
|
|
end
|
|
|
|
def self.server_port=(port)
|
|
@server_port = port
|
|
end
|
|
|
|
def self.select_server_port
|
|
21000 + rand(10000)
|
|
end
|
|
|
|
def self.server_interface
|
|
'127.0.0.1'
|
|
end
|
|
|
|
def self.server_uri
|
|
"http://#{server_interface}:#{server_port}"
|
|
end
|
|
|
|
def self.server_spec_path
|
|
self.server_uri + '/__JHW__/'
|
|
end
|
|
|
|
def self.ensure_server(options)
|
|
return if @server
|
|
|
|
require 'webrick'
|
|
require 'thread'
|
|
require 'rack'
|
|
require 'net/http'
|
|
|
|
port = server_port
|
|
|
|
@server = Thread.new do
|
|
Jasmine::Headless.warn "Powering up!"
|
|
|
|
app = Rack::Builder.new do
|
|
use IndexHandler
|
|
|
|
map '/__JHW__' do
|
|
run Rack::File.new(Dir.pwd)
|
|
end
|
|
|
|
map '/' do
|
|
run Rack::File.new('/')
|
|
end
|
|
end
|
|
|
|
Rack::Handler::WEBrick.run(
|
|
app,
|
|
:Port => port,
|
|
:Logger => Logger.new(StringIO.new),
|
|
:AccessLog => [
|
|
[ StringIO.new, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
|
|
[ StringIO.new, WEBrick::AccessLog::REFERER_LOG_FORMAT ]
|
|
]
|
|
)
|
|
end
|
|
|
|
while true do
|
|
begin
|
|
Net::HTTP.get(URI(server_uri))
|
|
break
|
|
rescue Errno::ECONNREFUSED => e
|
|
end
|
|
|
|
sleep 0.1
|
|
end
|
|
end
|
|
|
|
def initialize(options)
|
|
options = Options.new(options) if !options.kind_of?(Options)
|
|
|
|
@options = options
|
|
end
|
|
|
|
def template_writer
|
|
@template_writer ||= TemplateWriter.new(self)
|
|
end
|
|
|
|
def jasmine_config
|
|
return @jasmine_config if @jasmine_config
|
|
|
|
@jasmine_config = JASMINE_DEFAULTS.dup
|
|
jasmine_config_data.each do |key, value|
|
|
@jasmine_config[key] = value if value
|
|
end
|
|
@jasmine_config
|
|
end
|
|
|
|
def jasmine_command(*targets)
|
|
command = [ RUNNER ]
|
|
|
|
command << "-s #{options[:seed]}"
|
|
command << '-c' if options[:colors]
|
|
command << '-q' if options[:quiet]
|
|
|
|
options.file_reporters.each do |reporter, identifier, file|
|
|
command << "-r #{file}"
|
|
end
|
|
|
|
command += targets
|
|
command.compact.join(' ')
|
|
end
|
|
|
|
def run
|
|
Jasmine::Headless::CacheableAction.enabled = @options[:enable_cache]
|
|
Jasmine::Headless.show_warnings = !@options[:quiet]
|
|
FilesList.reset!
|
|
|
|
self.class.server_port = options[:server_port]
|
|
|
|
@_targets = template_writer.write
|
|
|
|
run_targets = absolute_run_targets(@_targets.dup)
|
|
|
|
if run_targets.length == 2
|
|
if (!@options[:full_run] && files_list.filtered?) || files_list.has_spec_outside_scope?
|
|
run_targets.pop
|
|
end
|
|
end
|
|
|
|
runner = lambda {
|
|
raise "Error #{$?} while attempting to run '#{jasmine_command(run_targets)}', probably because jasmine-webkit-specrunner hasn't been compiled." if system(jasmine_command(run_targets)) == 127
|
|
}
|
|
|
|
if options[:use_server]
|
|
wrap_in_server(run_targets, &runner)
|
|
else
|
|
runner.call
|
|
end
|
|
|
|
@_status = $?.exitstatus
|
|
ensure
|
|
# if @_targets && !runner_filename && (@options[:remove_html_file] || (@_status == 0))
|
|
# @_targets.each { |target| FileUtils.rm_f target }
|
|
# end
|
|
end
|
|
|
|
def launch_command(cmd)
|
|
Open3.popen3(cmd) {|stdin, stdout, stderr, wait_thr|
|
|
pid = wait_thr.pid # pid of the started process.
|
|
|
|
|
|
|
|
exit_status = wait_thr.value # Process::Status object returned.
|
|
}
|
|
end
|
|
|
|
def absolute_run_targets(targets)
|
|
targets.flatten.collect do |target|
|
|
if options[:use_server]
|
|
target = self.class.server_spec_path + target
|
|
else
|
|
target = "file://" + File.expand_path(target)
|
|
end
|
|
target
|
|
end
|
|
end
|
|
|
|
def runner_filename
|
|
options[:runner_output_filename] || begin
|
|
if (runner_output = jasmine_config['runner_output']) && !runner_output.empty?
|
|
runner_output
|
|
else
|
|
false
|
|
end
|
|
end
|
|
end
|
|
|
|
def files_list
|
|
@files_list ||= Jasmine::Headless::FilesList.new(
|
|
:config => jasmine_config,
|
|
:only => options[:files],
|
|
:seed => options[:seed],
|
|
:reporters => options.reporters
|
|
)
|
|
end
|
|
|
|
def wrap_in_server(run_targets)
|
|
self.class.ensure_server(options)
|
|
IndexHandler.index = run_targets.last
|
|
|
|
Jasmine::Headless.warn "HTTP powered specs! Located at #{run_targets.join(' ')}"
|
|
|
|
yield
|
|
end
|
|
|
|
private
|
|
def jasmine_config_data
|
|
raise JasmineConfigNotFound.new("Jasmine config not found. I tried #{@options[:jasmine_config]}.") if !File.file?(@options[:jasmine_config])
|
|
|
|
YAML.load(ERB.new(File.read(@options[:jasmine_config])).result(binding))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|