github-migration/jasmine-headless-webkit
1
0
Fork 0
Code Issues 39 Pull Requests 16 Packages Projects Releases Wiki Activity

whoa actually just plug in sprockets, need to backfill tests later since i have real work to do

Browse Source
This commit is contained in:
John Bintz 2011-11-22 10:36:42 -05:00
parent 130a65ecdd
commit 7d75b5466f
16 changed files with 141 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/jasmine/headless.rb
View File

@ -11,12 +11,12 @@ module Jasmine::Headless
autoload :Options, 'jasmine/headless/options'
autoload :Task, 'jasmine/headless/task'
autoload :FilesList, 'jasmine/headless/files_list'
autoload :RequiredFile, 'jasmine/headless/required_file'
autoload :PathSearcher, 'jasmine/headless/path_searcher'
autoload :TemplateWriter, 'jasmine/headless/template_writer'
autoload :CoffeeTemplate, 'jasmine/headless/coffee_template'
autoload :JSTemplate, 'jasmine/headless/js_template'
autoload :CSSTemplate, 'jasmine/headless/css_template'
autoload :Report, 'jasmine/headless/report'
autoload :ReportMessage, 'jasmine/headless/report_message'

2
lib/jasmine/headless/coffee_template.rb
View File

@ -2,6 +2,8 @@ require 'tilt/template'
module Jasmine::Headless
class CoffeeTemplate < Tilt::Template
self.default_mime_type = 'application/javascript'
def prepare ; end
def evaluate(scope, locals, &block)

14
lib/jasmine/headless/css_template.rb Normal file
View File

@ -0,0 +1,14 @@
require 'tilt/template'
module Jasmine::Headless
class CSSTemplate < Tilt::Template
self.default_mime_type = 'text/css'
def prepare ; end
def evaluate(scope, locals, &block)
file ? %{<link rel="stylesheet" href="#{file}" type="text/css" />} : data
end
end
end

76
lib/jasmine/headless/files_list.rb
View File

@ -42,6 +42,8 @@ module Jasmine::Headless
end
register_engine '.coffee', Jasmine::Headless::CoffeeTemplate
register_engine '.js', Jasmine::Headless::JSTemplate
register_engine '.css', Jasmine::Headless::CSSTemplate
end
end
@ -61,18 +63,20 @@ module Jasmine::Headless
@potential_files_to_filter = []
self.class.default_files.each do |file|
@required_files << RequiredFile.new(*[ path_searcher.find(file.dup), self ].flatten)
@required_files << sprockets_environment.find_asset(file, :bundle => false)
end
use_config! if config?
end
def files
required_files.collect { |file| file.file_paths }.flatten.uniq
required_files.collect { |file| file.send(:required_assets).collect { |asset| asset.pathname.to_s } }.flatten.uniq
end
def spec_files
filter_for_requested_specs(required_files.find_all(&:spec_file?).collect(&:path))
filter_for_requested_specs(
files.find_all { |file| spec_dir.any? { |dir| file[dir] } }
)
end
def filtered_files
@ -90,6 +94,17 @@ module Jasmine::Headless
@search_paths
end
def sprockets_environment
return @sprockets_environment if @sprockets_environment
@sprockets_environment = Sprockets::Environment.new
search_paths.each do |path|
@sprockets_environment.append_path(path)
end
@sprockets_environment
end
def path_searcher
@path_searcher ||= PathSearcher.new(self)
end
@ -98,10 +113,13 @@ module Jasmine::Headless
if is_outside_scope = !spec_filter.empty?
is_outside_scope = spec_dir.any? do |dir|
spec_file_searches.any? do |search|
!spec_files.any? { |file| File.fnmatch?(File.join(dir, search), file) }
!spec_files.any? { |file|
File.fnmatch?(File.join(dir, search), file)
}
end
end
end
is_outside_scope
end
@ -139,11 +157,7 @@ module Jasmine::Headless
alert_time = nil
end
search_paths.collect do |path|
if file[%r{^#{path}}]
Jasmine::Headless::RequiredFile.new(file, path, self).to_html
end
end.compact.first
sprockets_environment.find_asset(file, :bundle => false).to_s
end.flatten.compact.reject(&:empty?)
end
@ -178,6 +192,16 @@ module Jasmine::Headless
add_files(@searches[type] = data.flatten, type, dirs)
end
end
filtered_required_files = []
@required_files.each do |file|
if !filtered_required_files.any? { |other_file| other_file.logical_path == file.logical_path }
filtered_required_files << file
end
end
@required_files = filtered_required_files
end
def add_files(patterns, type, dirs)
@ -186,36 +210,16 @@ module Jasmine::Headless
search = File.expand_path(File.join(dir, search))
Dir[search].find_all { |file| file[extension_filter] }.each do |path|
@required_files << (file = RequiredFile.new(path, dir, self))
if type == 'spec_files'
file.spec_file = true
@potential_files_to_filter << path
end
add_path(path, type) if File.file?(path)
end
end
end
if type == 'spec_files'
spec_filter.each do |path|
@required_files << (file = RequiredFile.new(path, nil, self))
file.spec_file = true
@potential_files_to_filter << path
spec_filter.each { |path| add_path(path, type) }
end
end
filtered_required_files = []
@required_files.each do |file|
if !filtered_required_files.any? { |other_file| other_file == file }
filtered_required_files << file
end
end
@required_files = filtered_required_files
end
def config?
@options[:config]
end
@ -228,8 +232,14 @@ module Jasmine::Headless
%r{(#{(%w{.js .css} + Sprockets.engine_extensions).join('|')})$}
end
def add_file(file)
@files << file
def add_path(path, type)
asset = sprockets_environment.find_asset(path, :bundle => false)
@required_files << asset
if type == 'spec_files'
@potential_files_to_filter << path
end
end
def include_spec_file?(file)

14
lib/jasmine/headless/js_template.rb Normal file
View File

@ -0,0 +1,14 @@
require 'tilt/template'
module Jasmine::Headless
class JSTemplate < Tilt::Template
self.default_mime_type = 'application/javascript'
def prepare ; end
def evaluate(scope, locals, &block)
file ? %{<script type="text/javascript" src="#{file}"></script>} : data
end
end
end

34
lib/jasmine/headless/path_searcher.rb
View File

@ -1,34 +0,0 @@
require 'sprockets'
require 'forwardable'
module Jasmine::Headless
class PathSearcher
extend Forwardable
def_delegators :source, :search_paths, :extension_filter
attr_reader :source
def initialize(source)
@source = source
end
def find(file)
search_paths.each do |dir|
Dir[File.join(dir, "#{file}*")].find_all { |path| File.file?(path) }.each do |path|
root = path.gsub(%r{^#{dir}/}, '')
ok = (root == file)
ok ||= File.basename(path.gsub("#{file}.", '')).split('.').all? { |part| ".#{part}"[extension_filter] }
if ok
return [ File.expand_path(path), dir ]
end
end
end
false
end
end
end

121
lib/jasmine/headless/required_file.rb
View File

@ -1,121 +0,0 @@
require 'rainbow'
require 'sprockets'
require 'forwardable'
module Jasmine::Headless
class RequiredFile
extend Forwardable
def_delegators :parent, :path_searcher, :extension_filter
attr_reader :path, :source_root, :parent
attr_writer :spec_file
def initialize(path, source_root, parent)
@path, @source_root, @parent = path, source_root, parent
@spec_file = false
end
def spec_file?
@spec_file
end
def ==(other)
self.path == other.path
end
def to_html
process_data_by_filename(path)
end
def has_dependencies?
!dependencies.empty?
end
def includes?(path)
@path == path || dependencies.any? { |dependency| dependency.includes?(path) }
end
def file_paths
paths = dependencies.collect(&:file_paths).flatten
if @insert_after
paths.insert(paths.index(@insert_after) + 1, path)
else
paths << path
end
paths
end
def dependencies
return @dependencies if @dependencies
processor = Sprockets::DirectiveProcessor.new(path)
last_file_added = nil
@dependencies = processor.directives.collect do |line, type, name|
if name && name[%r{^\.}]
name = File.expand_path(File.join(File.dirname(path), name)).gsub(%r{^#{source_root}/}, '')
else
raise Sprockets::ArgumentError.new("require_tree needs a relative path: ./#{path}") if type == 'require_tree'
end
files = case type
when 'require'
[ name ]
when 'require_tree'
Dir[File.join(source_root, name, '**/*')].find_all { |found_path|
found_path != path && File.file?(found_path) && found_path[extension_filter]
}.sort.collect { |path| path.gsub(%r{^#{source_root}/}, '') }
when 'require_self'
@insert_after = last_file_added
[]
else
[]
end
files.collect do |file|
if result = path_searcher.find(file)
new_file = self.class.new(*[ result, self ].flatten)
last_file_added = new_file.path
new_file
else
raise Sprockets::FileNotFound.new("Could not find #{file}, referenced from #{path}:#{line}")
end
end
end.flatten
end
def logical_path
path.gsub(%r{^#{source_root}/}, '').gsub(%r{\..+$}, '')
end
private
def read
File.read(path)
end
def process_data_by_filename(path, data = nil)
case extension = File.extname(path)
when ''
data || ''
when '.js'
data || %{<script type="text/javascript" src="#{path}"></script>}
when '.css'
data || %{<link rel="stylesheet" href="#{path}" type="text/css" />}
else
if engine = Sprockets.engines(extension)
data = engine.new(path) { data || read }.render(self)
data = %{<script type="text/javascript">#{data}</script>} if extension == '.jst'
process_data_by_filename(path.gsub(%r{#{extension}$}, ''), data)
else
data || ''
end
end
end
end
end

2
lib/jasmine/headless/spec_file_analyzer.rb
View File

@ -14,7 +14,7 @@ module Jasmine::Headless
data = File.read(file)
if data.respond_to?(:encode)
data.encode!('US-ASCII', 'UTF-8', :invalid => :replace)
data.encode!('US-ASCII', 'UTF-8', :invalid => :replace, :undef => :replace)
else
require 'iconv'
ic = Iconv.new('UTF-8//IGNORE', 'US-ASCII')

180
spec/lib/jasmine/headless/files_list_spec.rb
View File

@ -27,160 +27,8 @@ describe Jasmine::Headless::FilesList do
end
end
describe '#use_config' do
let(:files_list) { described_class.new(:config => config) }
include FakeFS::SpecHelpers
no_default_files!
let(:src_dir) { 'src' }
let(:spec_dir) { 'spec' }
let(:first_file) { File.join(src_dir, 'js/first_file.js') }
let(:src_file) { File.join(src_dir, 'js/src_file.js') }
let(:spec_file) { File.join(spec_dir, 'spec_file_spec.js') }
let(:helper_file) { File.join(spec_dir, 'helper/helper_file.js') }
let(:stylesheet_file) { File.join(src_dir, 'stylesheet/blah.css') }
before do
[ first_file, src_file, spec_file, helper_file, stylesheet_file ].each do |file|
FileUtils.mkdir_p File.split(file).first
File.open(file, 'w')
end
end
shared_examples_for :reading_data do
let(:expected_files) do
[
File.expand_path(first_file),
File.expand_path(src_file),
File.expand_path(stylesheet_file),
File.expand_path(helper_file),
File.expand_path(spec_file)
]
end
it 'should read the data from the jasmine.yml file and add the files' do
files_list.files.should == expected_files
files_list.spec_files.should == [ File.expand_path(spec_file) ]
end
end
context 'with normal list' do
let(:config) { {
'src_dir' => src_dir,
'spec_dir' => spec_dir,
'src_files' => [ 'js/first_file.js', 'js/*.js' ],
'spec_files' => [ '*_spec.js' ],
'helpers' => [ 'helper/*.js' ],
'stylesheets' => [ 'stylesheet/*.css' ]
} }
it_should_behave_like :reading_data
end
context 'with multidimensional list' do
let(:config) { {
'src_dir' => src_dir,
'spec_dir' => spec_dir,
'src_files' => [ [ 'js/first_file.js', 'js/*.js' ] ],
'spec_files' => [ '*_spec.js' ],
'helpers' => [ 'helper/*.js' ],
'stylesheets' => [ 'stylesheet/*.css' ]
} }
it_should_behave_like :reading_data
end
context 'with multidimensional src dir' do
let(:config) { {
'src_dir' => [ src_dir ],
'spec_dir' => spec_dir,
'src_files' => [ [ 'js/first_file.js', 'js/*.js' ] ],
'spec_files' => [ '*_spec.js' ],
'helpers' => [ 'helper/*.js' ],
'stylesheets' => [ 'stylesheet/*.css' ]
} }
it_should_behave_like :reading_data
end
end
context 'with filtered specs' do
let(:files_list) { Jasmine::Headless::FilesList.new(:only => filter, :config => config) }
let(:spec_dir) { 'spec' }
include FakeFS::SpecHelpers
no_default_files!
let(:config) { {
'spec_files' => [ '*_spec.js' ],
'spec_dir' => spec_dir
} }
let(:spec_files) { %w{one_spec.js two_spec.js whatever.js} }
before do
spec_files.each do |file|
FileUtils.mkdir_p spec_dir
File.open(File.join(spec_dir, file), 'w')
end
end
context 'empty filter' do
let(:filter) { [] }
it 'should return all files for filtered and all files' do
files_list.files.any? { |file| file['two_spec.js'] }.should be_true
files_list.filtered?.should be_false
files_list.should_not have_spec_outside_scope
files_list.spec_files.sort.should == %w{one_spec.js two_spec.js}.sort.collect { |file| File.expand_path(File.join(spec_dir, file)) }
end
end
context 'filter with a file that is matchable' do
let(:filter) { [ File.expand_path('spec/one_spec.js') ] }
it 'should return all files for files' do
files_list.files.any? { |file| file['two_spec.js'] }.should be_true
files_list.filtered?.should be_true
files_list.should_not have_spec_outside_scope
files_list.spec_files.should == filter
end
it 'should return only filtered files for filtered_files' do
files_list.filtered_files.any? { |file| file['two_spec.js'] }.should be_false
files_list.should_not have_spec_outside_scope
end
end
context 'filter with a glob' do
let(:filter) { [ File.expand_path('spec/one*') ] }
it 'should return all files for files' do
files_list.files.any? { |file| file['two_spec.js'] }.should be_true
files_list.filtered?.should be_true
files_list.should_not have_spec_outside_scope
end
it 'should return only filtered files for filtered_files' do
files_list.filtered_files.any? { |file| file['two_spec.js'] }.should be_false
files_list.should_not have_spec_outside_scope
end
end
context 'filter with a file that is not even there' do
let(:filter) { [ File.expand_path('spec/whatever.js') ] }
it 'should use the provided file' do
files_list.filtered_files.any? { |file| file['whatever.js'] }.should be_true
files_list.should have_spec_outside_scope
end
end
end
it 'should have tests for #use_config!'
it 'should have tests for #add_files'
describe '#spec_file_line_numbers' do
include FakeFS::SpecHelpers
@ -274,8 +122,12 @@ describe Jasmine::Headless::FilesList do
let(:path_two) { 'two' }
let(:path_three) { 'three' }
let(:file_one) { stub(:file_paths => [ path_one, path_two ] ) }
let(:file_two) { stub(:file_paths => [ path_two, path_three ] ) }
let(:file_one) { stub(:required_assets => [ asset_one, asset_two ] ) }
let(:file_two) { stub(:required_assets => [ asset_two, asset_three ] ) }
let(:asset_one) { stub(:pathname => Pathname(path_one)) }
let(:asset_two) { stub(:pathname => Pathname(path_two)) }
let(:asset_three) { stub(:pathname => Pathname(path_three)) }
before do
files_list.stubs(:required_files).returns([ file_one, file_two ])
@ -323,21 +175,5 @@ describe Jasmine::Headless::FilesList do
it { should == [ file_one, file_two, file_four ] }
end
end
describe '#files_to_html' do
let(:file_one) { 'path/one' }
let(:file_two) { 'path/two' }
before do
files_list.stubs(:files).returns([ file_one, file_two ])
files_list.stubs(:search_paths).returns([ 'path' ])
Jasmine::Headless::RequiredFile.any_instance.stubs(:to_html).returns('made it')
end
it 'should render all the files' do
files_list.files_to_html.should == [ 'made it', 'made it' ]
end
end
end

40
spec/lib/jasmine/headless/path_searcher_spec.rb
View File

@ -1,40 +0,0 @@
require 'spec_helper'
describe Jasmine::Headless::PathSearcher do
include FakeFS::SpecHelpers
let(:path) { File.expand_path('path') }
let(:paths) { [ path ] }
let(:source) { stub(:search_paths => paths, :extension_filter => %r{.*}) }
let(:path_searcher) { described_class.new(source) }
let(:filename) { 'file.js' }
let(:file) { File.join(path, filename) }
describe '#find' do
subject { path_searcher.find(search) }
before do
FileUtils.mkdir_p path
File.open(file, 'wb')
end
context 'found file' do
let(:search) { 'file' }
it 'should find the file' do
subject.should == [ File.expand_path(file), path ]
end
end
context 'not found file' do
let(:search) { 'other' }
it 'should not find the file' do
subject.should be_false
end
end
end
end

240
spec/lib/jasmine/headless/required_file_spec.rb
View File

@ -1,240 +0,0 @@
require 'spec_helper'
describe Jasmine::Headless::RequiredFile do
let(:source_root) { File.expand_path('source_root') }
let(:path) { File.join(source_root, 'path.js') }
let(:file) { described_class.new(path, source_root, files_list) }
let(:paths) { [ source_root ] }
let(:path_searcher) { stub }
let(:files_list) { stub(:path_searcher => path_searcher) }
subject { file }
its(:path) { should == path }
its(:source_root) { should == source_root }
its(:parent) { should == files_list }
describe '#has_dependencies?' do
it 'should have dependencies' do
file.instance_variable_set(:@dependencies, [ 1 ])
file.should have_dependencies
end
it 'should not have dependencies' do
file.instance_variable_set(:@dependencies, [])
file.should_not have_dependencies
end
end
describe '#includes?' do
it 'includes itself' do
file.includes?(path).should be_true
end
context 'with dependencies' do
let(:other_file) { stub }
let(:other_path) { 'other path' }
let(:third_path) { 'third path' }
before do
other_file.stubs(:includes?).with(other_path).returns(true)
other_file.stubs(:includes?).with(third_path).returns(false)
file.stubs(:dependencies).returns([ other_file ])
end
it 'checks dependencies' do
file.includes?(third_path).should be_false
file.includes?(other_path).should be_true
end
end
end
describe '#to_html' do
subject { file.to_html }
context '.js' do
let(:path) { 'path.js' }
it { should == %{<script type="text/javascript" src="#{path}"></script>} }
end
context '.css' do
let(:path) { 'path.css' }
it { should == %{<link rel="stylesheet" href="#{path}" type="text/css" />} }
end
context 'with tilt template' do
include FakeFS::SpecHelpers
let(:content) { 'content' }
before do
File.open(path, 'wb') { |fh| fh.print content }
end
let(:klass) do
Class.new(Tilt::Template) do
def prepare ; end
def evaluate(scope, locals, &block)
"#{file} made it #{data}"
end
end
end
let(:other_klass) do
Class.new(Tilt::Template) do
def prepare ; end
def evaluate(scope, locals, &block)
data
end
end
end
before do
Sprockets.stubs(:engines).with('.tilt').returns(klass)
Sprockets.stubs(:engines).with('.jst').returns(other_klass)
end
context '.tilt' do
let(:path) { 'path.tilt' }
it { should == %{#{path} made it #{content}} }
end
context '.tilt.tilt' do
let(:path) { 'path.tilt.tilt' }
it { should == %{path.tilt made it #{path} made it #{content}} }
end
context '.jst.tilt' do
let(:path) { 'path.jst.tilt' }
it { should == %{<script type="text/javascript">#{path} made it #{content}</script>} }
end
end
end
describe '#dependencies' do
include FakeFS::SpecHelpers
let(:directive) { 'require' }
let(:dirname) { 'subdir/subsubdir' }
let(:dir) { File.join(source_root, dirname) }
let(:path) { path_file }
let(:path_file) { File.join(dir, 'path.js') }
let(:req_file) { File.join(dir, "req.js") }
let(:other_file) { File.join(dir, "other.js") }
let(:content) { "//= #{directive} '#{req_name}'\njavascript" }
before do
FileUtils.mkdir_p dir
File.open(path_file, 'wb') { |fh| fh.print content }
File.open(req_file, 'wb')
File.open(other_file, 'wb')
end
subject { file.dependencies }
context 'absolute' do
context 'require' do
context 'file exists' do
let(:req_name) { File.join(dirname, 'req') }
before do
path_searcher.expects(:find).with(File.join(dirname, 'req')).returns([ req_file, source_root ])
end
it { should == [ described_class.new(req_file, source_root, file) ] }
end
context 'file does not exist' do
let(:req_name) { File.join(dirname, 'bad') }
before do
path_searcher.expects(:find).with(File.join(dirname, 'bad')).returns(false)
end
it 'should raise an exception' do
expect { subject }.to raise_error(Sprockets::FileNotFound)
end
end
end
end
context 'relative' do
context 'require' do
context 'file exists' do
let(:req_name) { './req' }
before do
path_searcher.expects(:find).with(File.join(dirname, 'req')).returns([ req_file, source_root ])
end
it { should == [ described_class.new(req_file, source_root, file) ] }
end
context 'file does not exist' do
let(:req_name) { './bad' }
before do
path_searcher.expects(:find).with(File.join(dirname, 'bad')).returns(false)
end
it 'should raise an exception' do
expect { subject }.to raise_error(Sprockets::FileNotFound)
end
end
end
end
context 'require_self' do
subject { file.file_paths }
let(:content) do
<<-ENDTXT
//= require #{dirname}/req
//= require_self
//= require #{dirname}/other
ENDTXT
end
before do
path_searcher.expects(:find).with(File.join(dirname, 'req')).returns([ req_file, source_root ])
path_searcher.expects(:find).with(File.join(dirname, 'other')).returns([ other_file, source_root ])
end
it { should == [
req_file,
path_file,
other_file
] }
end
end
describe '#file_paths' do
let(:other_path) { File.join(source_root, 'other_path.js') }
let(:other_file) { described_class.new(other_path, source_root, file) }
before do
file.stubs(:dependencies).returns([ other_file ])
other_file.stubs(:dependencies).returns([])
end
it 'should flatten all the paths in itself and descendents' do
file.file_paths.should == [ other_path, path ]
end
end
end

19
vendor/assets/javascripts/headless_reporter_result.js vendored
View File

@ -1,13 +1,16 @@
(function() {
window.HeadlessReporterResult = (function() {
function HeadlessReporterResult(name, splitName) {
this.name = name;
this.splitName = splitName;
this.results = [];
}
HeadlessReporterResult.prototype.addResult = function(message) {
return this.results.push(message);
};
HeadlessReporterResult.prototype.print = function() {
var bestChoice, output, result, _i, _len, _ref, _results;
output = this.name.foreground('red');
@ -25,10 +28,15 @@
output += (" (line ~" + (bestChoice.lineNumber + result.lineNumber) + ")").foreground('red').bright();
}
JHW.stdout.puts(" " + output);
_results.push(result.line != null ? JHW.stdout.puts((" " + result.line).foreground('yellow')) : void 0);
if (result.line != null) {
_results.push(JHW.stdout.puts((" " + result.line).foreground('yellow')));
} else {
_results.push(void 0);
}
}
return _results;
};
HeadlessReporterResult.findSpecLine = function(splitName) {
var bestChoice, file, index, lastLine, line, lineNumber, lines, newLineNumberInfo, _i, _len, _ref;
bestChoice = {
@ -49,9 +57,7 @@
for (_i = 0, _len = newLineNumberInfo.length; _i < _len; _i++) {
line = newLineNumberInfo[_i];
lastLine = line;
if (line > lineNumber) {
break;
}
if (line > lineNumber) break;
}
lineNumber = lastLine;
}
@ -67,6 +73,7 @@
}
return bestChoice;
};
return HeadlessReporterResult;
})();
}).call(this);

7
vendor/assets/javascripts/intense.js vendored
View File

@ -1,5 +1,6 @@
(function() {
var code, method, _ref;
window.Intense = {
colors: {
black: 0,
@ -29,15 +30,15 @@
},
useColors: true,
moveBack: function(count) {
if (count == null) {
count = 1;
}
if (count == null) count = 1;
return "\033[" + count + "D";
}
};
_ref = Intense.methods;
for (method in _ref) {
code = _ref[method];
String.prototype[method] = code;
}
}).call(this);

9
vendor/assets/javascripts/jasmine-extensions.js vendored
View File

@ -1,9 +1,11 @@
(function() {
var generator, getSplitName, method, pauseAndRun, _i, _len, _ref;
var __slice = Array.prototype.slice;
if (!(typeof jasmine !== "undefined" && jasmine !== null)) {
throw new Error("jasmine not laoded!");
}
if (window.JHW) {
getSplitName = function(parts) {
parts.push(String(this.description).replace(/[\n\r]/g, ' '));
@ -110,7 +112,11 @@
_results = [];
for (_j = 0, _len2 = _ref2.length; _j < _len2; _j++) {
reporter = _ref2[_j];
_results.push(reporter[method] != null ? reporter[method].apply(reporter, args) : void 0);
if (reporter[method] != null) {
_results.push(reporter[method].apply(reporter, args));
} else {
_results.push(void 0);
}
}
return _results;
};
@ -119,4 +125,5 @@
}
}
}
}).call(this);

50
vendor/assets/javascripts/jasmine.HeadlessConsoleReporter.js vendored
View File

@ -1,9 +1,10 @@
(function() {
var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
if (!(typeof jasmine !== "undefined" && jasmine !== null)) {
throw new Error("jasmine not loaded!");
}
jasmine.HeadlessConsoleReporter = (function() {
function HeadlessConsoleReporter(callback) {
this.callback = callback != null ? callback : null;
this.results = [];
@ -13,11 +14,10 @@
this.position = 0;
this.positions = "|/-\\";
}
HeadlessConsoleReporter.prototype.reportRunnerResults = function(runner) {
var output, result, resultLine, runtime, _i, _len, _ref;
if (this.hasError()) {
return;
}
if (this.hasError()) return;
runtime = (new Date() - this.startTime) / 1000.0;
JHW.stdout.print("\n");
resultLine = this._formatResultLine(runtime);
@ -34,22 +34,20 @@
result = _ref[_i];
result.print();
}
if (window.JHW) {
window.onbeforeunload = null;
}
if (window.JHW) window.onbeforeunload = null;
return JHW.finishSuite();
};
HeadlessConsoleReporter.prototype.reportRunnerStarting = function(runner) {
this.startTime = new Date();
if (!this.hasError()) {
return JHW.stdout.puts("\nRunning Jasmine specs...".bright());
}
};
HeadlessConsoleReporter.prototype.reportSpecResults = function(spec) {
var failureResult, foundLine, result, results, testCount, _i, _len, _ref;
if (this.hasError()) {
return;
}
if (this.hasError()) return;
JHW.ping();
results = spec.results();
this.length++;
@ -76,35 +74,37 @@
return this.results.push(failureResult);
}
};
HeadlessConsoleReporter.prototype.reportSpecStarting = function(spec) {
if (this.hasError()) {
spec.finish();
return spec.suite.finish();
}
};
HeadlessConsoleReporter.prototype.reportSpecWaiting = function() {
var first, runner;
var _this = this;
runner = null;
if (!this.timer) {
this.timer = true;
first = true;
runner = __bind(function() {
return this.timer = setTimeout(__bind(function() {
if (this.timer) {
if (!first) {
JHW.stdout.print(Intense.moveBack());
}
JHW.stdout.print(this.positions.substr(this.position, 1).foreground('yellow'));
this.position += 1;
this.position %= this.positions.length;
runner = function() {
return _this.timer = setTimeout(function() {
if (_this.timer) {
if (!first) JHW.stdout.print(Intense.moveBack());
JHW.stdout.print(_this.positions.substr(_this.position, 1).foreground('yellow'));
_this.position += 1;
_this.position %= _this.positions.length;
first = false;
return runner();
}
}, this), 750);
}, this);
}, 750);
};
return runner();
}
};
HeadlessConsoleReporter.prototype.reportSpecRunning = function() {
if (this.timer) {
clearTimeout(this.timer);
@ -112,10 +112,13 @@
return JHW.stdout.print(Intense.moveBack());
}
};
HeadlessConsoleReporter.prototype.reportSuiteResults = function(suite) {};
HeadlessConsoleReporter.prototype.hasError = function() {
return JHW._hasErrors;
};
HeadlessConsoleReporter.prototype._formatResultLine = function(runtime) {
var line;
line = [];
@ -127,6 +130,7 @@
line.push((runtime === 1.0 ? "sec" : "secs") + '.');
return line.join(' ');
};
return HeadlessConsoleReporter;
})();
}).call(this);

8
vendor/assets/javascripts/prolog.js vendored
View File

@ -1,5 +1,6 @@
(function() {
var createHandle, handle, _i, _len, _ref;
if (window.JHW) {
window.console = {
log: function(data) {
@ -40,9 +41,7 @@
e = e || window.event;
JHW.hasError();
JHW.stdout.puts('The code tried to leave the test page. Check for unhandled form submits and link clicks.');
if (e) {
e.returnValue = 'string';
}
if (e) e.returnValue = 'string';
return 'string';
};
window.confirm = function(message) {
@ -84,6 +83,9 @@
return JHW.stdout.puts(msg);
};
}
window.CoffeeScriptToFilename = {};
window.CSTF = window.CoffeeScriptToFilename;
}).call(this);