rally-jasmine 1.2.0

data/lib/jasmine/results.rb

@@ -0,0 +1,19 @@
+module Jasmine
+  class Results
+
+    attr_reader :suites
+    def initialize(result_hash, suite_hash, example_locations)
+      @suites = suite_hash
+      @results = result_hash
+      @example_locations = example_locations
+    end
+
+    def for_spec_id(id)
+      @results[id]
+    end
+
+    def example_location_for(spec_description)
+      @example_locations[spec_description]
+    end
+  end
+end

data/lib/jasmine/results_processor.rb

@@ -0,0 +1,37 @@
+module Jasmine
+  class ResultsProcessor
+
+    def initialize(config)
+      @config = config
+    end
+
+    def process(results_hash, suites_hash)
+      return Jasmine::Results.new(results_hash, suites_hash, example_locations)
+    end
+
+    def example_locations
+      example_locations = {}
+      example_name_parts = []
+      previous_indent_level = 0
+      @config.spec_files_full_paths.each do |filename|
+        line_number = 1
+        File.open(filename, "r") do |file|
+          file.readlines.each do |line|
+            match = /^(\s*)(describe|it)\s*\(\s*["'](.*)["']\s*,\s*function/.match(line)
+             if (match)
+               indent_level = match[1].length / 2
+               example_name = match[3]
+               example_name_parts[indent_level] = example_name
+
+               full_example_name = example_name_parts.slice(0, indent_level + 1).join(" ")
+               example_locations[full_example_name] = "#{filename}:#{line_number}: in `it'"
+             end
+             line_number += 1
+          end
+        end
+      end
+      example_locations
+    end
+
+  end
+end

data/lib/jasmine/rspec_formatter.rb

@@ -0,0 +1,92 @@
+require 'enumerator'
+
+module Jasmine
+  class RspecFormatter
+
+    def format_results(results)
+      @results = results
+      declare_suites(@results.suites)
+    end
+
+    def declare_suites(suites)
+      suites.each do |suite|
+        #empty block for rspec 1
+        group = example_group(suite["name"]) {}
+        process_children(group, suite["children"])
+      end
+    end
+
+    def process_children(parent, children)
+      children.each do |suite_or_spec|
+        type = suite_or_spec["type"]
+        if type == "suite"
+          process_children(parent.describe(suite_or_spec["name"]), suite_or_spec["children"])
+        elsif type == "spec"
+          declare_spec(parent, suite_or_spec)
+        else
+          raise "unknown type #{type} for #{suite_or_spec.inspect}"
+        end
+      end
+    end
+
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+      backtrace = @results.example_location_for(parent.description + " " + example_name)
+      if Jasmine::Dependencies.rspec2?
+        parent.it example_name, {} do
+          me.report_spec(spec["id"])
+        end
+      else
+        parent.it example_name, {}, backtrace do
+          me.report_spec(spec["id"])
+        end
+      end
+    end
+
+    def report_spec(spec_id)
+      spec_results = results_for(spec_id)
+      out = ""
+      messages = spec_results['messages'].each do |message|
+        case
+        when message["type"] == "log"
+          puts message["text"]
+          puts "\n"
+        else
+          unless message["message"] =~ /^Passed.$/
+            STDERR << message["message"]
+            STDERR << "\n"
+
+            out << message["message"]
+            out << "\n"
+          end
+
+          if !message["passed"] && message["trace"]["stack"]
+            stack_trace = message["trace"]["stack"].gsub(/<br \/>/, "\n").gsub(/<\/?b>/, " ")
+            STDERR << stack_trace.gsub(/\(.*\)@http:\/\/localhost:[0-9]+\/specs\//, "/spec/")
+            STDERR << "\n"
+          end
+        end
+
+      end
+      fail out unless spec_results['result'] == 'passed'
+      puts out unless out.empty?
+    end
+
+    private
+
+    def example_group(*args, &block)
+      if Jasmine::Dependencies.rspec2?
+        RSpec::Core::ExampleGroup.describe(*args, &block).register
+      else
+        Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
+      end
+    end
+
+    def results_for(spec_id)
+      @results.for_spec_id(spec_id.to_s)
+    end
+
+
+  end
+end

data/lib/jasmine/run.html.erb

@@ -0,0 +1,55 @@
+<!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">
+    //TODO: make this a js file that gets passed in, then iterate over only js_files
+    var jsApiReporter;
+    (function() {
+      var jasmineEnv = jasmine.getEnv();
+
+      jsApiReporter = new jasmine.JsApiReporter();
+      var htmlReporter = new jasmine.HtmlReporter();
+
+      jasmineEnv.addReporter(jsApiReporter);
+      jasmineEnv.addReporter(htmlReporter);
+
+      jasmineEnv.specFilter = function(spec) {
+        return htmlReporter.specFilter(spec);
+      };
+
+      var currentWindowOnload = window.onload;
+
+      window.onload = function() {
+        if (currentWindowOnload) {
+          currentWindowOnload();
+        }
+        execJasmine();
+      };
+
+      function execJasmine() {
+        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/run_specs.rb

@@ -0,0 +1,32 @@
+$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
+
+require 'rubygems'
+require 'jasmine'
+jasmine_config_overrides = File.expand_path(File.join(Dir.pwd, 'spec', 'javascripts', 'support', 'jasmine_config.rb'))
+require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+if Jasmine::Dependencies.rspec2?
+  require 'rspec'
+else
+  require 'spec'
+end
+
+jasmine_runner_config = Jasmine::RunnerConfig.new
+server = Jasmine::Server.new(jasmine_runner_config.port, Jasmine::Application.app(jasmine_runner_config))
+client = Jasmine::SeleniumDriver.new(jasmine_runner_config.browser, jasmine_runner_config.jasmine_server_url)
+
+t = Thread.new do
+  begin
+    server.start
+  rescue ChildProcess::TimeoutError
+  end
+  # # ignore bad exits
+end
+t.abort_on_exception = true
+Jasmine::wait_for_listener(jasmine_runner_config.port, "jasmine server")
+puts "jasmine server started."
+
+results_processor = Jasmine::ResultsProcessor.new(jasmine_runner_config)
+results = Jasmine::Runners::HTTP.new(client, results_processor, jasmine_runner_config.result_batch_size).run
+formatter = Jasmine::RspecFormatter.new
+formatter.format_results(results)
+

data/lib/jasmine/runner_config.rb

@@ -0,0 +1,71 @@
+module Jasmine
+  class RunnerConfig
+    def initialize(config = Jasmine::Config.new)
+      @config = config
+    end
+
+    def css_files
+      @config.jasmine_stylesheets + @config.user_stylesheets
+    end
+
+    def jasmine_files
+      @config.jasmine_javascripts
+    end
+
+    def js_files
+      @config.js_files
+    end
+
+    def spec_files
+      @config.spec_files
+    end
+
+    def spec_files_full_paths
+      @config.spec_files_full_paths
+    end
+
+    def spec_path
+      @config.spec_path
+    end
+
+    def spec_dir
+      @config.spec_dir
+    end
+
+    def src_dir
+      @config.src_dir
+    end
+
+    def project_root
+      @config.project_root
+    end
+
+    def root_path
+      @config.root_path
+    end
+
+    def browser
+      ENV["JASMINE_BROWSER"] || 'firefox'
+    end
+
+    def port
+      @config.port
+    end
+
+    def jasmine_server_url
+      "#{@config.jasmine_host}:#{@config.port}/"
+    end
+
+    def src_mapper=(context)
+      @config.src_mapper = context
+    end
+
+    def src_mapper
+      @config.src_mapper
+    end
+
+    def result_batch_size
+      ENV["JASMINE_RESULT_BATCH_SIZE"] ? ENV["JASMINE_RESULT_BATCH_SIZE"].to_i : 50
+    end
+  end
+end

data/lib/jasmine/runners/http.rb

@@ -0,0 +1,71 @@
+module Jasmine
+  module Runners
+    class HTTP
+      attr_accessor :suites
+
+      def initialize(client, results_processor, result_batch_size)
+        @client = client
+        @results_processor = results_processor
+        @result_batch_size = result_batch_size
+      end
+
+      def run
+        @client.connect
+        load_suite_info
+        wait_for_suites_to_finish_running
+        results = @results_processor.process(results_hash, suites)
+        @client.disconnect
+        results
+      end
+
+      private
+
+      def load_suite_info
+        started = Time.now
+        while !eval_js('return jsApiReporter && jsApiReporter.started') do
+          raise "couldn't connect to Jasmine after 60 seconds" if (started + 60 < Time.now)
+          sleep 0.1
+        end
+
+        @suites = eval_js("var result = jsApiReporter.suites(); if (window.Prototype && Object.toJSON) { return Object.toJSON(result) } else { return JSON.stringify(result) }")
+      end
+
+      def results_hash
+        spec_results = {}
+        spec_ids.each_slice(@result_batch_size) do |slice|
+          spec_results.merge!(eval_js("var result = jsApiReporter.resultsForSpecs(#{json_generate(slice)}); if (window.Prototype && Object.toJSON) { return Object.toJSON(result) } else { return JSON.stringify(result) }"))
+        end
+        spec_results
+      end
+
+      def spec_ids
+        map_spec_ids = lambda do |suites|
+          suites.map do |suite_or_spec|
+            if suite_or_spec['type'] == 'spec'
+              suite_or_spec['id']
+            else
+              map_spec_ids.call(suite_or_spec['children'])
+            end
+          end
+        end
+        map_spec_ids.call(@suites).compact.flatten
+      end
+
+      def wait_for_suites_to_finish_running
+        puts "Waiting for suite to finish in browser ..."
+        while !eval_js('return jsApiReporter.finished') do
+          sleep 0.1
+        end
+      end
+
+      def eval_js(script)
+        @client.eval_js(script)
+      end
+
+      def json_generate(obj)
+        @client.json_generate(obj)
+      end
+
+    end
+  end
+end

data/lib/jasmine/selenium_driver.rb

@@ -0,0 +1,52 @@
+module Jasmine
+  class SeleniumDriver
+    def initialize(browser, http_address)
+      require 'selenium-webdriver'
+
+      ::Selenium::WebDriver::Driver.send(:attr_accessor, :bridge)
+      ::Selenium::WebDriver::Remote::Bridge.send(:attr_accessor, :http)
+      ::Selenium::WebDriver::Remote::Http::Default.send(:attr_accessor, :server_url)
+
+      selenium_server = if ENV['SELENIUM_SERVER']
+        ENV['SELENIUM_SERVER']
+      elsif ENV['SELENIUM_SERVER_PORT']
+        "http://localhost:#{ENV['SELENIUM_SERVER_PORT']}/wd/hub"
+      end
+      options = if browser == "firefox" && ENV["JASMINE_FIREBUG"]
+                  require File.join(File.dirname(__FILE__), "firebug/firebug")
+                  profile = Selenium::WebDriver::Firefox::Profile.new
+                  profile.enable_firebug
+                  {:profile => profile}
+                end || {}
+      @driver = if selenium_server
+        Selenium::WebDriver.for :remote, :url => selenium_server, :desired_capabilities => browser.to_sym
+      else
+        Selenium::WebDriver.for browser.to_sym, options
+      end
+      @http_address = http_address
+    end
+
+    def connect
+      wdsid = @driver.bridge.session_id
+      wduri = @driver.bridge.http.server_url
+
+      wdurl = "#{wduri.scheme}://#{wduri.host}:#{wduri.port}/wd/hub"
+      url = "#{@http_address}?wdurl=#{URI.encode(wdurl)}&wdsid=#{URI.encode(wdsid)}"
+      @driver.navigate.to url
+      url
+    end
+
+    def disconnect
+      @driver.quit
+    end
+
+    def eval_js(script)
+      result = @driver.execute_script(script)
+      JSON.parse("{\"result\":#{result}}", :max_nesting => false)["result"]
+    end
+
+    def json_generate(obj)
+      JSON.generate(obj)
+    end
+  end
+end

data/lib/jasmine/server.rb

@@ -0,0 +1,20 @@
+module Jasmine
+  class Server
+    def initialize(port = 8888, application = Jasmine::Application.app)
+      @port = port
+      @application = application
+    end
+
+    def start
+      if Jasmine::Dependencies.legacy_rack?
+        handler = Rack::Handler.get('webrick')
+        handler.run(@application, :Port => @port, :AccessLog => [])
+      else
+        server = Rack::Server.new(:Port => @port, :AccessLog => [])
+        # workaround for Rack bug, when Rack > 1.2.1 is released Rack::Server.start(:app => Jasmine.app(self)) will work
+        server.instance_variable_set(:@app, @application)
+        server.start
+      end
+    end
+  end
+end

data/lib/jasmine/sprockets_mapper.rb

@@ -0,0 +1,13 @@
+class Jasmine::SprocketsMapper
+  def initialize(context, mount_point = 'assets')
+    @context = context
+    @mount_point = mount_point
+  end
+
+  def files(src_files)
+    src_files.map do |src_file|
+      filename = src_file.gsub(/^assets\//, '').gsub(/\.js$/, '')
+      @context.find_asset(filename).to_a.map(&:logical_path).map(&:to_s)
+    end.flatten.uniq.map{|path| File.join(@mount_point, path).to_s + "?body=true"}
+  end
+end

data/lib/jasmine/tasks/jasmine.rake

@@ -0,0 +1,56 @@
+namespace :jasmine do
+  task :require do
+    require 'jasmine'
+  end
+
+  task :require_json do
+    begin
+      require 'json'
+    rescue LoadError
+      puts "You must have a JSON library installed to run jasmine:ci. Try \"gem install json\""
+      exit
+    end
+  end
+
+  desc "Run continuous integration tests"
+  task :ci => ["jasmine:require_json", "jasmine:require"] do
+    if Jasmine::Dependencies.rspec2?
+      require "rspec"
+      require "rspec/core/rake_task"
+    else
+      require "spec"
+      require 'spec/rake/spectask'
+    end
+
+    if Jasmine::Dependencies.rspec2?
+      RSpec::Core::RakeTask.new(:jasmine_continuous_integration_runner) do |t|
+        t.rspec_opts = ["--colour", "--format", ENV['JASMINE_SPEC_FORMAT'] || "progress"]
+        t.verbose = true
+        if Jasmine::Dependencies.rails_3_asset_pipeline?
+          t.rspec_opts += ["-r #{File.expand_path(File.join(::Rails.root, 'config', 'environment'))}"]
+        end
+        t.pattern = [Jasmine.runner_filepath]
+      end
+    else
+      Spec::Rake::SpecTask.new(:jasmine_continuous_integration_runner) do |t|
+        t.spec_opts = ["--color", "--format", ENV['JASMINE_SPEC_FORMAT'] || "specdoc"]
+        t.verbose = true
+        t.spec_files = [Jasmine.runner_filepath]
+      end
+    end
+    Rake::Task["jasmine_continuous_integration_runner"].invoke
+  end
+
+  task :server => "jasmine:require" do
+    jasmine_config_overrides = File.join(Jasmine::Config.new.project_root, 'spec', 'javascripts' ,'support' ,'jasmine_config.rb')
+    require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+
+    port = ENV['JASMINE_PORT'] || 8888
+    puts "your tests are here:"
+    puts "  http://localhost:#{port}/"
+    Jasmine::Server.new(port).start
+  end
+end
+
+desc "Run specs via server"
+task :jasmine => ['jasmine:server']

data/lib/jasmine/tasks/jasmine_rails3.rake

@@ -0,0 +1 @@
+task "jasmine:require" => [:environment]

data/lib/jasmine/version.rb

@@ -0,0 +1,3 @@
+module Jasmine
+  VERSION = "1.2.0"
+end

data/lib/jasmine.rb

@@ -0,0 +1,23 @@
+jasmine_files = ['base',
+                 'dependencies',
+                 'runner_config',
+                 'config',
+                 'application',
+                 'server',
+                 'selenium_driver',
+                 'rspec_formatter',
+                 'command_line_tool',
+                 'page',
+                 'asset_pipeline_mapper',
+                 'sprockets_mapper',
+                 'results_processor',
+                 'results',
+                 File.join('runners', 'http')]
+
+jasmine_files.each do |file|
+  require File.join('jasmine', file)
+end
+
+require File.join('jasmine', "railtie") if Jasmine::Dependencies.rails3?
+
+

data/lib/rack/jasmine/cache_control.rb

@@ -0,0 +1,20 @@
+module Rack
+  module Jasmine
+
+    class CacheControl
+      def initialize(app)
+        @app, @content_type = app
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        headers = Rack::Utils::HeaderHash.new(headers)
+        headers['Cache-Control'] ||= "max-age=0, private, must-revalidate"
+        headers['Pragma'] ||= "no-cache"
+        [status, headers, body]
+      end
+    end
+
+  end
+end
+

data/lib/rack/jasmine/focused_suite.rb

@@ -0,0 +1,17 @@
+module Rack
+  module Jasmine
+
+    class FocusedSuite
+      def initialize(runner_config)
+        @runner_config = runner_config
+      end
+
+      def call(env)
+        run_adapter = Rack::Jasmine::RunAdapter.new(@runner_config)
+        run_adapter.run(env["PATH_INFO"])
+      end
+    end
+
+  end
+end
+

data/lib/rack/jasmine/redirect.rb

@@ -0,0 +1,20 @@
+module Rack
+  module Jasmine
+
+    class Redirect
+      def initialize(url)
+        @url = url
+      end
+
+      def call(env)
+        [
+          302,
+          { 'Location' => @url },
+          []
+        ]
+      end
+    end
+
+  end
+end
+

data/lib/rack/jasmine/runner.rb

@@ -0,0 +1,27 @@
+module Rack
+  module Jasmine
+
+    class Runner
+      def initialize(page)
+        @page = page
+      end
+
+      def call(env)
+        @path = env["PATH_INFO"]
+        return not_found if @path != "/"
+        [
+          200,
+          { 'Content-Type' => 'text/html'},
+          [@page.render]
+        ]
+      end
+
+      def not_found
+        [404, {"Content-Type" => "text/plain",
+               "X-Cascade" => "pass"},
+               ["File not found: #{@path}\n"]]
+      end
+    end
+
+  end
+end