satisfaction-jasmine 0.4.3

data/lib/jasmine.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'jasmine/base'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'jasmine/config'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'jasmine/server'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'jasmine/selenium_driver'))
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'jasmine/spec_builder'))

data/lib/jasmine/base.rb

@@ -0,0 +1,63 @@
+require 'socket'
+require 'erb'
+require 'json'
+
+module Jasmine
+  def self.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.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
+end

data/lib/jasmine/config.rb

@@ -0,0 +1,166 @@
+module Jasmine
+  class Config
+    require 'yaml'
+
+    def initialize(options = {})
+      require 'selenium_rc'
+      @selenium_jar_path = SeleniumRC::Server.allocate.jar_path
+      @options = options
+
+      @browser = options[:browser] ? options.delete(:browser) : 'firefox'
+      @selenium_pid = nil
+      @jasmine_server_pid = nil
+    end
+
+    def start_server(port = 8888)
+      Jasmine::Server.new(port, self).start
+    end
+
+    def start
+      start_servers
+      @client = Jasmine::SeleniumDriver.new("localhost", @selenium_server_port, "*#{@browser}", "http://localhost:#{@jasmine_server_port}/")
+      @client.connect
+    end
+
+    def stop
+      @client.disconnect
+      stop_servers
+    end
+
+    def start_servers
+      @jasmine_server_port = Jasmine::find_unused_port
+      @selenium_server_port = Jasmine::find_unused_port
+
+      server = Jasmine::Server.new(@jasmine_server_port, self)
+
+      @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_server_pid = fork do
+        Process.setpgrp
+        server.start
+        exit! 0
+      end
+      puts "jasmine server started.  pid is #{@jasmine_server_pid}"
+
+      Jasmine::wait_for_listener(@selenium_server_port, "selenium server")
+      Jasmine::wait_for_listener(@jasmine_server_port, "jasmine server")
+    end
+
+    def stop_servers
+      puts "shutting down the servers..."
+      Jasmine::kill_process_group(@selenium_pid) if @selenium_pid
+      Jasmine::kill_process_group(@jasmine_server_pid) if @jasmine_server_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
+
+    def match_files(dir, patterns)
+      dir = File.expand_path(dir)
+      patterns.collect do |pattern|
+        Dir.glob(File.join(dir, pattern)).collect {|f| f.sub("#{dir}/", "/")}.sort
+      end.flatten
+    end
+
+    def simple_config
+      config = File.exist?(simple_config_file) ? File.open(simple_config_file) { |yf| YAML::load( yf ) } : false
+      config || {}
+    end
+
+
+    def spec_path
+      "/__spec__"
+    end
+
+    def root_path
+      "/__root__"
+    end
+
+    def mappings
+      {
+        spec_path => spec_dir,
+        root_path => project_root
+      }
+    end
+
+    def js_files
+      src_files + spec_files.collect {|f| File.join(spec_path, f) }
+    end
+
+    def css_files
+      stylesheets
+    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 src_files
+      if simple_config['src_files']
+        if simple_config['src_base_url']
+          return simple_config['src_files'].map {|f| File.join(simple_config['src_base_url'], f)}
+        else
+          return match_files(src_dir, simple_config['src_files'])
+        end
+      end
+      return []
+    end
+
+    def spec_files
+      files = match_files(spec_dir, "**/*.js")
+      if simple_config['spec_files']
+        files = match_files(spec_dir, simple_config['spec_files'])
+      end
+      files
+    end
+
+    def stylesheets
+      files = []
+      if simple_config['stylesheets']
+        files = match_files(src_dir, simple_config['stylesheets'])
+      end
+      files
+    end
+
+  end
+end

data/lib/jasmine/run.html.erb

@@ -0,0 +1,43 @@
+<!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>
+  <% 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,44 @@
+module Jasmine
+  class SeleniumDriver
+    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\":#{result}}")["result"]
+    end
+  end
+end

data/lib/jasmine/server.rb

@@ -0,0 +1,125 @@
+module Jasmine
+  class RunAdapter
+    def initialize(config)
+      @config = config
+      @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",
+      ]
+      @jasmine_stylesheets = ["/__JASMINE_ROOT__/lib/jasmine.css"]
+    end
+
+    def call(env)
+      run
+    end
+
+    #noinspection RubyUnusedLocalVariable
+    def run
+      jasmine_files = @jasmine_files
+      css_files = @jasmine_stylesheets + (@config.css_files || [])
+      js_files = @config.js_files
+
+      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
+#      @spec_files_or_proc = spec_files_or_proc || []
+#      @options = options
+    end
+
+    def call(env)
+      spec_files = @config.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 Server
+    attr_reader :thin
+
+    def initialize(port, config)
+      @port = port
+      @config = config
+
+      require 'thin'
+      thin_config = {
+        '/__suite__' => Jasmine::FocusedSuite.new(@config),
+        '/run.html' => Jasmine::Redirect.new('/'),
+        '/' => Jasmine::RunAdapter.new(@config)
+      }
+
+      @config.mappings.each do |from, to|
+        thin_config[from] = Rack::File.new(to)
+      end
+
+      thin_config["/__JASMINE_ROOT__"] = Rack::File.new(Jasmine.root)
+
+      app = Rack::Cascade.new([
+        Rack::URLMap.new({'/' => Rack::File.new(@config.src_dir)}),
+        Rack::URLMap.new(thin_config),
+        JsAlert.new
+      ])
+
+      @thin = Thin::Server.new('0.0.0.0', @port, app)
+    end
+
+    def start
+      begin
+        thin.start
+      rescue RuntimeError => e
+        raise e unless e.message == 'no acceptor'
+        raise RuntimeError.new("A server is already running on port #{@port}")
+      end
+    end
+
+    def stop
+      thin.stop
+    end
+  end
+end