evergreen 0.1 → 0.2.0

data/lib/jasmine/Rakefile

@@ -1,38 +1,34 @@
-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 += 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"
+def jasmine_html_sources
+  ["src/html/TrivialReporter.js"]
 end
 
-def version_hash
-  JSON.parse(File.new("src/version.json").read);
+def jasmine_version
+  "#{version_hash['major']}.#{version_hash['minor']}.#{version_hash['build']}"
 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)
+def version_hash
+  require 'json'
+  @version ||= JSON.parse(File.new("src/version.json").read);
 end
 
 task :default => 'jasmine:dist'
 
+def substitute_jasmine_version(filename)
+  contents = File.read(filename)
+  contents = contents.gsub(/##JASMINE_VERSION##/, (jasmine_version))
+  File.open(filename, 'w') { |f| f.write(contents) }
+end
+
 namespace :jasmine do
 
   desc 'Prepares for distribution'
-  task :dist => ['jasmine:build', 'jasmine:doc']
+  task :dist => ['jasmine:build', 'jasmine:doc', 'jasmine:build_example_project', 'jasmine:fill_index_downloads']
 
   desc 'Check jasmine sources for coding problems'
   task :lint do
@@ -46,6 +42,11 @@ namespace :jasmine do
           puts "Dangerous undefined at #{src}:#{i}:\n > #{line}"
           passed = false
         end
+
+        if line.scan(/window/).length > 0
+          puts "Dangerous window at #{src}:#{i}:\n > #{line}"
+          passed = false
+        end
       end
     end
 
@@ -58,89 +59,118 @@ namespace :jasmine do
   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')
+    old_jasmine_files.each { |file| File.delete(file) }
 
-    sources.each do |source_filename|
-      jasmine.puts(File.read(source_filename))
-    end
+    File.open("lib/jasmine.js", 'w') do |jasmine|
+      sources.each do |source_filename|
+        jasmine.puts(File.read(source_filename))
+      end
 
-    jasmine.puts %{
+      jasmine.puts %{
 jasmine.version_= {
   "major": #{version['major']},
   "minor": #{version['minor']},
   "build": #{version['build']},
   "revision": #{Time.now.to_i}
-  };
+};
 }
+    end
+
+    File.open("lib/jasmine-html.js", 'w') do |jasmine_html|
+      jasmine_html_sources.each do |source_filename|
+        jasmine_html.puts(File.read(source_filename))
+      end
+    end
+
+    FileUtils.cp("src/html/jasmine.css", "lib/jasmine.css")
+  end
 
-    jasmine.close
+  task :need_pages_submodule do
+    unless File.exists?('pages/index.html')
+      raise "Jasmine pages submodule isn't present.  Run git submodule update --init"
+    end
   end
 
   desc "Build jasmine documentation"
-  task :doc do
+  task :doc => :need_pages_submodule do
     puts 'Creating Jasmine Documentation'
     require 'rubygems'
     #sudo gem install ragaskar-jsdoc_helper
     require 'jsdoc_helper'
 
+    FileUtils.rm_r "pages/jsdoc", :force => true
 
     JsdocHelper::Rake::Task.new(:lambda_jsdoc) do |t|
-      t[:files] = jasmine_sources << 'lib/TrivialReporter.js'
+      t[:files] = jasmine_sources << jasmine_html_sources
       t[:options] = "-a"
+      t[:out] = "pages/jsdoc"
     end
     Rake::Task[:lambda_jsdoc].invoke
   end
 
+  desc "Build example project"
+  task :build_example_project => :need_pages_submodule do
+    require 'tmpdir'
+
+    temp_dir = File.join(Dir.tmpdir, 'jasmine-standalone-project')
+    puts "Building Example Project in #{temp_dir}"
+    FileUtils.rm_r temp_dir if File.exists?(temp_dir)
+    Dir.mkdir(temp_dir)
+
+    root = File.expand_path(File.dirname(__FILE__))
+    FileUtils.cp_r File.join(root, 'example/.'), File.join(temp_dir)
+    substitute_jasmine_version(File.join(temp_dir, "SpecRunner.html"))
+
+    lib_dir = File.join(temp_dir, "lib/jasmine-#{jasmine_version}")
+    FileUtils.mkdir_p(lib_dir)
+    {
+        "lib/jasmine.js" => "jasmine.js",
+        "lib/jasmine-html.js" => "jasmine-html.js",
+        "src/html/jasmine.css" => "jasmine.css"
+    }.each_pair do |src, dest|
+      FileUtils.cp(File.join(root, src), File.join(lib_dir, dest))
+    end
 
-  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
-
-  task :server_build => 'jasmine:build' do
-
-    start_jasmine_server
+    dist_dir = File.join(root, 'pages/downloads')
+    zip_file_name = File.join(dist_dir, "jasmine-standalone-#{jasmine_version}.zip")
+    puts "Zipping Example Project and moving to #{zip_file_name}"
+    FileUtils.mkdir(dist_dir) unless File.exist?(dist_dir)
+    if File.exist?(zip_file_name)
+      puts "WARNING!!! #{zip_file_name} already exists!"
+      FileUtils.rm(zip_file_name)
+    end
+    exec "cd #{temp_dir} && zip -r #{zip_file_name} . -x .[a-zA-Z0-9]*"
   end
 
-  namespace :test do
-    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
-
-      task :saucelabs => ['jasmine:copy_saucelabs_config', 'jasmine:build'] do
-        ENV['SAUCELABS'] = 'true'
-        Rake::Task['jasmine:test:ci:local'].invoke
-      end
+  task :fill_index_downloads do
+    require 'digest/sha1'
+
+    download_html = "<!-- START_DOWNLOADS -->\n"
+    download_html += "<table>\n<tr><th/><th>Version</th><th>Size</th><th>Date</th><th>SHA1</th></tr>\n"
+    Dir.glob('pages/downloads/*.zip').sort.reverse.each do |f|
+      sha1 = Digest::SHA1.hexdigest File.read(f)
+
+      fn = f.sub(/^pages\//, '')
+      version = /jasmine-standalone-(.*).zip/.match(f)[1]
+      download_html += "<td><a href='#{fn}'>#{fn.sub(/downloads\//, '')}</a></td>"
+      download_html += "<td>#{version}</td>\n"
+      download_html += "<td>#{File.size(f) / 1024}k</td>\n"
+      download_html += "<td>#{File.mtime(f).strftime("%Y/%m/%d %H:%M:%S")}</td>\n"
+      download_html += "<td>#{sha1}</td>\n"
     end
-  end
+    download_html += "</table>\n<!-- END_DOWNLOADS -->"
 
-  desc 'Copy saucelabs.yml to work directory'
-  task 'copy_saucelabs_config' do
-    FileUtils.cp '../saucelabs.yml', 'spec'
+    index_page = File.read('pages/index.html')
+    matcher = /<!-- START_DOWNLOADS -->.*<!-- END_DOWNLOADS -->/m
+    index_page = index_page.sub(matcher, download_html)
+    File.open('pages/index.html', 'w') {|f| f.write(index_page)}
+    puts "rewrote that file"
   end
 end
 
-task :jasmine => ['jasmine:server']
+task :jasmine => ['jasmine:dist']

data/lib/jasmine/example/SpecRunner.html

@@ -0,0 +1,27 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+  <title>Jasmine Test Runner</title>
+  <link rel="stylesheet" type="text/css" href="lib/jasmine-##JASMINE_VERSION##/jasmine.css">
+  <script type="text/javascript" src="lib/jasmine-##JASMINE_VERSION##/jasmine.js"></script>
+  <script type="text/javascript" src="lib/jasmine-##JASMINE_VERSION##/jasmine-html.js"></script>
+
+  <!-- include source files here... -->
+  <script type="text/javascript" src="src/Player.js"></script>
+  <script type="text/javascript" src="src/Song.js"></script>
+
+  <!-- include spec files here... -->
+  <script type="text/javascript" src="spec/SpecHelper.js"></script>
+  <script type="text/javascript" src="spec/PlayerSpec.js"></script>
+
+</head>
+<body>
+<script type="text/javascript">
+  jasmine.getEnv().addReporter(new jasmine.TrivialReporter());
+  jasmine.getEnv().execute();
+</script>
+
+</body>
+</html>
+  

data/lib/jasmine/example/spec/PlayerSpec.js

@@ -0,0 +1,58 @@
+describe("Player", function() {
+  var player;
+  var song;
+
+  beforeEach(function() {
+    player = new Player();
+    song = new Song();
+  });
+
+  it("should be able to play a Song", function() {
+    player.play(song);
+    expect(player.currentlyPlayingSong).toEqual(song);
+
+    //demonstrates use of custom matcher
+    expect(player).toBePlaying(song);
+  });
+
+  describe("when song has been paused", function() {
+    beforeEach(function() {
+      player.play(song);
+      player.pause();
+    });
+
+    it("should indicate that the song is currently paused", function() {
+      expect(player.isPlaying).toBeFalsy();
+
+      // demonstrates use of 'not' with a custom matcher
+      expect(player).not.toBePlaying(song);
+    });
+
+    it("should be possible to resume", function() {
+      player.resume();
+      expect(player.isPlaying).toBeTruthy();
+      expect(player.currentlyPlayingSong).toEqual(song);
+    });
+  });
+
+  // demonstrates use of spies to intercept and test method calls
+  it("tells the current song if the user has made it a favorite", function() {
+    spyOn(song, 'persistFavoriteStatus');
+
+    player.play(song);
+    player.makeFavorite();
+
+    expect(song.persistFavoriteStatus).toHaveBeenCalledWith(true);
+  });
+
+  //demonstrates use of expected exceptions
+  describe("#resume", function() {
+    it("should throw an exception if song is already playing", function() {
+      player.play(song);
+
+      expect(function() {
+        player.resume();
+      }).toThrow("song is already playing");
+    });
+  });
+});

data/lib/jasmine/example/spec/SpecHelper.js

@@ -0,0 +1,9 @@
+beforeEach(function() {
+  this.addMatchers({
+    toBePlaying: function(expectedSong) {
+      var player = this.actual;
+      return player.currentlyPlayingSong === expectedSong
+          && player.isPlaying;
+    }
+  })
+});

data/lib/jasmine/example/src/Player.js

@@ -0,0 +1,22 @@
+function Player() {
+}
+Player.prototype.play = function(song) {
+  this.currentlyPlayingSong = song;
+  this.isPlaying = true;
+};
+
+Player.prototype.pause = function() {
+  this.isPlaying = false;
+};
+
+Player.prototype.resume = function() {
+  if (this.isPlaying) {
+    throw new Error("song is already playing");
+  }
+
+  this.isPlaying = true;
+};
+
+Player.prototype.makeFavorite = function() {
+  this.currentlyPlayingSong.persistFavoriteStatus(true);
+};

data/lib/jasmine/example/src/Song.js

@@ -0,0 +1,7 @@
+function Song() {
+}
+
+Song.prototype.persistFavoriteStatus = function(value) {
+  // something complicated
+  throw new Error("not yet implemented");
+};

data/lib/jasmine/lib/jasmine-html.js

@@ -0,0 +1,182 @@
+jasmine.TrivialReporter = function(doc) {
+  this.document = doc || document;
+  this.suiteDivs = {};
+  this.logRunningSpecs = false;
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) { el.appendChild(child); }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+  var showPassed, showSkipped;
+
+  this.outerDiv = this.createDom('div', { className: 'jasmine_reporter' },
+      this.createDom('div', { className: 'banner' },
+        this.createDom('div', { className: 'logo' },
+            "Jasmine",
+            this.createDom('span', { className: 'version' }, runner.env.versionString())),
+        this.createDom('div', { className: 'options' },
+            "Show ",
+            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
+            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
+            )
+          ),
+
+      this.runnerDiv = this.createDom('div', { className: 'runner running' },
+          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
+          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
+          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
+      );
+
+  this.document.body.appendChild(this.outerDiv);
+
+  var suites = runner.suites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    var suiteDiv = this.createDom('div', { className: 'suite' },
+        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
+    this.suiteDivs[suite.id] = suiteDiv;
+    var parentDiv = this.outerDiv;
+    if (suite.parentSuite) {
+      parentDiv = this.suiteDivs[suite.parentSuite.id];
+    }
+    parentDiv.appendChild(suiteDiv);
+  }
+
+  this.startedAt = new Date();
+
+  var self = this;
+  showPassed.onchange = function(evt) {
+    if (evt.target.checked) {
+      self.outerDiv.className += ' show-passed';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
+    }
+  };
+
+  showSkipped.onchange = function(evt) {
+    if (evt.target.checked) {
+      self.outerDiv.className += ' show-skipped';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
+    }
+  };
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+  var results = runner.results();
+  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+  this.runnerDiv.setAttribute("class", className);
+  //do it twice for IE
+  this.runnerDiv.setAttribute("className", className);
+  var specs = runner.specs();
+  var specCount = 0;
+  for (var i = 0; i < specs.length; i++) {
+    if (this.specFilter(specs[i])) {
+      specCount++;
+    }
+  }
+  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
+  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
+
+  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+  var results = suite.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.totalCount == 0) { // todo: change this to check results.skipped
+    status = 'skipped';
+  }
+  this.suiteDivs[suite.id].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
+  if (this.logRunningSpecs) {
+    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+  }
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+  var results = spec.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+  var specDiv = this.createDom('div', { className: 'spec '  + status },
+      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(spec.getFullName()),
+        title: spec.getFullName()
+      }, spec.description));
+
+
+  var resultItems = results.getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    specDiv.appendChild(messagesDiv);
+  }
+
+  this.suiteDivs[spec.suite.id].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+  var console = jasmine.getGlobal().console;
+  if (console && console.log) console.log.apply(console, arguments);
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+  return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+  var paramMap = {};
+  var params = this.getLocation().search.substring(1).split('&');
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i].split('=');
+    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+  }
+
+  if (!paramMap["spec"]) return true;
+  return spec.getFullName().indexOf(paramMap["spec"]) == 0;
+};