josephholsten-jasmine 1.1.0.pre.1

data/lib/jasmine/base.rb

@@ -0,0 +1,66 @@
+require 'socket'
+require 'erb'
+
+module Jasmine
+  def self.root
+    ENV["JASMINE_ROOT"] || File.expand_path(File.join(File.dirname(__FILE__), '../../jasmine'))
+  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.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
+
+  def self.rspec2?
+    Gem.available? "rspec", ">= 2.0"
+  end
+  
+  def self.rails3?
+    Gem.available? "rails", ">= 3.0"
+  end
+end

data/lib/jasmine/command_line_tool.rb

@@ -0,0 +1,72 @@
+module Jasmine
+  class CommandLineTool
+    def cwd
+      File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+    end
+
+    def expand(*paths)
+      File.expand_path(File.join(*paths))
+    end
+
+    def template_path(filepath)
+      expand(cwd, File.join("generators/jasmine/templates", filepath))
+    end
+
+    def dest_path(filepath)
+      expand(Dir.pwd, filepath)
+    end
+
+    def copy_unless_exists(relative_path, dest_path = nil)
+      unless File.exist?(dest_path(relative_path))
+        FileUtils.copy(template_path(relative_path), dest_path(dest_path || relative_path))
+      end
+    end
+
+    def process(argv)
+      if argv[0] == 'init'
+        require 'fileutils'
+
+        FileUtils.makedirs('public/javascripts')
+        FileUtils.makedirs('spec/javascripts')
+        FileUtils.makedirs('spec/javascripts/support')
+        FileUtils.makedirs('spec/javascripts/helpers')
+
+        copy_unless_exists('jasmine-example/src/Player.js', 'public/javascripts/Player.js')
+        copy_unless_exists('jasmine-example/src/Song.js', 'public/javascripts/Song.js')
+        copy_unless_exists('jasmine-example/spec/PlayerSpec.js', 'spec/javascripts/PlayerSpec.js')
+        copy_unless_exists('jasmine-example/spec/SpecHelper.js', 'spec/javascripts/helpers/SpecHelper.js')
+        copy_unless_exists('spec/javascripts/support/jasmine_runner.rb')
+        copy_unless_exists('spec/javascripts/support/jasmine_config.rb')
+
+        rails_tasks_dir = dest_path('lib/tasks')
+        if File.exist?(rails_tasks_dir)
+          copy_unless_exists('lib/tasks/jasmine.rake')
+          copy_unless_exists('spec/javascripts/support/jasmine-rails.yml', 'spec/javascripts/support/jasmine.yml')
+        else
+          copy_unless_exists('spec/javascripts/support/jasmine.yml')
+          write_mode = 'w'
+          if File.exist?(dest_path('Rakefile'))
+            load dest_path('Rakefile')
+            write_mode = 'a'
+          end
+
+          require 'rake'
+          unless Rake::Task.task_defined?('jasmine')
+            File.open(dest_path('Rakefile'), write_mode) do |f|
+              f.write("\n" + File.read(template_path('lib/tasks/jasmine.rake')))
+            end
+          end
+        end
+        File.open(template_path('INSTALL'), 'r').each_line do |line|
+          puts line
+        end
+      elsif argv[0] == "license"
+        puts File.new(expand(cwd, "MIT.LICENSE")).read
+      else
+        puts "unknown command #{argv}"
+        puts "Usage: jasmine init"
+        puts "               license"
+      end
+    end
+  end
+end

data/lib/jasmine/config.rb

@@ -0,0 +1,190 @@
+module Jasmine
+  class Config
+    require 'yaml'
+    require 'erb'
+
+    def browser
+      ENV["JASMINE_BROWSER"] || 'firefox'
+    end
+
+    def jasmine_host
+      ENV["JASMINE_HOST"] || 'http://localhost'
+    end
+
+    def jasmine_port
+      ENV["JASMINE_PORT"] || Jasmine::find_unused_port
+    end
+
+    def start_server(port = 8888)
+      server = Rack::Server.new(:Port => port, :AccessLog => [])
+      server.instance_variable_set(:@app, Jasmine.app(self)) # workaround for Rack bug, when Rack > 1.2.1 is released Rack::Server.start(:app => Jasmine.app(self)) will work
+      server.start
+    end
+
+    def start
+      start_jasmine_server
+      @client = Jasmine::SeleniumDriver.new(browser, "#{jasmine_host}:#{@jasmine_server_port}/")
+      @client.connect
+    end
+
+    def stop
+      @client.disconnect
+    end
+
+    def start_jasmine_server
+      @jasmine_server_port = jasmine_port
+      Thread.new do
+        start_server(@jasmine_server_port)
+      end
+      Jasmine::wait_for_listener(@jasmine_server_port, "jasmine server")
+      puts "jasmine server started."
+    end
+
+    def windows?
+      require 'rbconfig'
+      ::RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+    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
+
+    def json_generate(obj)
+      @client.json_generate(obj)
+    end
+
+    def match_files(dir, patterns)
+      dir = File.expand_path(dir)
+      negative, positive = patterns.partition {|pattern| /^!/ =~ pattern}
+      chosen, negated = [positive, negative].collect do |patterns|
+        patterns.collect do |pattern|
+          matches = Dir.glob(File.join(dir, pattern.gsub(/^!/,'')))
+          matches.collect {|f| f.sub("#{dir}/", "")}.sort
+        end.flatten.uniq
+      end
+      chosen - negated
+    end
+
+    def simple_config
+      config = File.exist?(simple_config_file) ? YAML::load(ERB.new(File.read(simple_config_file)).result(binding)) : false
+      config || {}
+    end
+
+
+    def spec_path
+      "/__spec__"
+    end
+
+    def root_path
+      "/__root__"
+    end
+
+    def js_files(spec_filter = nil)
+      spec_files_to_include = spec_filter.nil? ? spec_files : match_files(spec_dir, [spec_filter])
+      src_files.collect {|f| "/" + f } + asset_files.collect {|f| asset_path + '/' + f} + helpers.collect {|f| File.join(spec_path, f) } + spec_files_to_include.collect {|f| File.join(spec_path, f) }
+    end
+
+    def css_files
+      stylesheets.collect {|f| "/" + f }
+    end
+
+    def spec_files_full_paths
+      spec_files.collect {|spec_file| File.join(spec_dir, spec_file) }
+    end
+
+    def project_root
+      Dir.pwd
+    end
+
+    def simple_config_file
+      File.join(project_root, 'spec/javascripts/support/jasmine.yml')
+    end
+
+    def src_dir
+      if simple_config['src_dir']
+        File.join(project_root, simple_config['src_dir'])
+      else
+        project_root
+      end
+    end
+
+    def spec_dir
+      if simple_config['spec_dir']
+        File.join(project_root, simple_config['spec_dir'])
+      else
+        File.join(project_root, 'spec/javascripts')
+      end
+    end
+
+    def helpers
+      if simple_config['helpers']
+        match_files(spec_dir, simple_config['helpers'])
+      else
+        match_files(spec_dir, ["helpers/**/*.js"])
+      end
+    end
+
+    def src_files
+      if simple_config['src_files']
+        match_files(src_dir, simple_config['src_files'])
+      else
+        []
+      end
+    end
+
+    def spec_files
+      if simple_config['spec_files']
+        match_files(spec_dir, simple_config['spec_files'])
+      else
+        match_files(spec_dir, ["**/*[sS]pec.js"])
+      end
+    end
+
+    def stylesheets
+      if simple_config['stylesheets']
+        match_files(src_dir, simple_config['stylesheets'])
+      else
+        []
+      end
+    end
+
+    def asset_path
+      '/__assets__'
+    end
+
+    def asset_dir
+      if simple_config['asset_dir']
+        File.join(project_root, simple_config['asset_dir'])
+      else
+        File.join(project_root, 'app/assets')
+      end
+    end
+
+    def asset_paths
+      if simple_config['asset_paths']
+        simple_config['asset_paths']
+      else
+        ['javascripts','stylesheets']
+      end
+    end
+
+    def asset_files
+      if simple_config['asset_files']
+        simple_config['asset_files']
+      else
+        []
+      end
+    end
+  end
+end

data/lib/jasmine/railtie.rb

@@ -0,0 +1,20 @@
+require "rails/railtie"
+module Jasmine
+  class Railtie < Rails::Railtie
+
+    config.before_configuration do
+      old_jasmine_rakefile = ::Rails.root.join('lib', 'tasks', 'jasmine.rake')
+      if old_jasmine_rakefile.exist? && !ENV["USE_JASMINE_RAKE"]
+        puts %Q{
+            You no longer need to have jasmine.rake in your project, as it is now automatically loaded
+            from the Jasmine gem. To silence this warning, set "USE_JASMINE_RAKE=true" in your environment
+            or remove jasmine.rake.
+          }
+      end
+    end
+
+    rake_tasks do
+      load "jasmine/tasks/jasmine.rake"
+    end
+  end
+end

data/lib/jasmine/run.html.erb

@@ -0,0 +1,44 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
+<head>
+  <meta content="text/html;charset=UTF-8" http-equiv="Content-Type"/>
+  <title>Jasmine suite</title>
+  <link rel="shortcut icon" type="image/png" href="/__JASMINE_ROOT__/images/jasmine_favicon.png">
+  <% css_files.each do |css_file| %>
+    <link rel="stylesheet" href="<%= css_file %>" type="text/css" media="screen"/>
+  <% end %>
+
+  <% jasmine_files.each do |jasmine_file| %>
+  <script src="<%= jasmine_file %>" type="text/javascript"></script>
+  <% end %>
+
+  <script type="text/javascript">
+    var jsApiReporter;
+    (function() {
+      var jasmineEnv = jasmine.getEnv();
+
+      jsApiReporter = new jasmine.JsApiReporter();
+      var trivialReporter = new jasmine.TrivialReporter();
+
+      jasmineEnv.addReporter(jsApiReporter);
+      jasmineEnv.addReporter(trivialReporter);
+
+      jasmineEnv.specFilter = function(spec) {
+        return trivialReporter.specFilter(spec);
+      };
+
+      window.onload = function() {
+        jasmineEnv.execute();
+      };
+    })();
+  </script>
+
+  <% js_files.each do |js_file| %>
+  <script src="<%= js_file %>" type="text/javascript"></script>
+  <% end %>
+
+</head>
+<body>
+<div id="jasmine_content"></div>
+</body>
+</html>

data/lib/jasmine/selenium_driver.rb

@@ -0,0 +1,49 @@
+module Jasmine
+  class SeleniumDriver
+    def initialize(browser, http_address)
+      require 'selenium-webdriver'
+      selenium_server = if ENV['SELENIUM_SERVER']
+        ENV['SELENIUM_SERVER']
+      elsif ENV['SELENIUM_SERVER_PORT']
+        "http://localhost:#{ENV['SELENIUM_SERVER_PORT']}/wd/hub"
+      end
+      @driver = if selenium_server
+        Selenium::WebDriver.for :remote, :url => selenium_server, :desired_capabilities => browser.to_sym
+      else
+        Selenium::WebDriver.for browser.to_sym
+      end
+      @http_address = http_address
+    end
+
+    def tests_have_finished?
+      @driver.execute_script("return window.jasmine.getEnv().currentRunner.finished") == "true"
+    end
+
+    def connect
+      @driver.navigate.to @http_address
+    end
+
+    def disconnect
+      @driver.quit
+    end
+
+    def run
+      until tests_have_finished? do
+        sleep 0.1
+      end
+
+      puts @driver.execute_script("return window.results()")
+      failed_count = @driver.execute_script("return window.jasmine.getEnv().currentRunner.results().failedCount").to_i
+      failed_count == 0
+    end
+
+    def eval_js(script)
+      result = @driver.execute_script(script)
+      JSON.parse("{\"result\":#{result}}")["result"]
+    end
+
+    def json_generate(obj)
+      JSON.generate(obj)
+    end
+  end
+end

data/lib/jasmine/server.rb

@@ -0,0 +1,106 @@
+require 'rack'
+require 'sprockets'
+
+module Jasmine
+  class RunAdapter
+    def initialize(config)
+      @config = config
+      @jasmine_files = [
+        "/__JASMINE_ROOT__/lib/jasmine.js",
+        "/__JASMINE_ROOT__/lib/jasmine-html.js",
+        "/__JASMINE_ROOT__/lib/json2.js",
+      ]
+      @jasmine_stylesheets = ["/__JASMINE_ROOT__/lib/jasmine.css"]
+    end
+
+    def call(env)
+      return not_found if env["PATH_INFO"] != "/"
+      run
+    end
+
+    def not_found
+      body = "File not found: #{@path_info}\n"
+      [404, {"Content-Type" => "text/plain",
+             "Content-Length" => body.size.to_s,
+             "X-Cascade" => "pass"},
+       [body]]
+    end
+
+    #noinspection RubyUnusedLocalVariable
+    def run(focused_suite = nil)
+      jasmine_files = @jasmine_files
+      css_files = @jasmine_stylesheets + (@config.css_files || [])
+      js_files = @config.js_files(focused_suite)
+      body = ERB.new(File.read(File.join(File.dirname(__FILE__), "run.html.erb"))).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(config)
+      @config = config
+    end
+
+    def call(env)
+      run_adapter = Jasmine::RunAdapter.new(@config)
+      run_adapter.run(env["PATH_INFO"])
+    end
+  end
+
+  def self.app(config)
+    Rack::Builder.app do
+      use Rack::Head
+
+      map('/run.html')         { run Jasmine::Redirect.new('/') }
+      map('/__suite__')        { run Jasmine::FocusedSuite.new(config) }
+
+      map('/__JASMINE_ROOT__') { run Rack::File.new(Jasmine.root) }
+      map(config.root_path)    { run Rack::File.new(config.project_root) }
+      map(config.asset_path) do
+        assets_server = Sprockets::Environment.new config.asset_dir
+        config.asset_paths.each {|p| assets_server.paths << p }
+        run assets_server
+      end
+      map(config.spec_path) do
+        server = Sprockets::Environment.new config.spec_dir
+        server.paths << '.'
+        run server
+      end
+
+      map('/') do
+        run Rack::Cascade.new([
+          Rack::URLMap.new('/' => Rack::File.new(config.src_dir)),
+          Jasmine::RunAdapter.new(config)
+        ])
+      end
+    end
+  end
+end