jasmine-headless-webkit 0.8.4 → 0.9.0.rc1

data/lib/jasmine/headless/runner.rb

@@ -4,11 +4,29 @@ require 'coffee-script'
 require 'rainbow'
 
 require 'yaml'
+require 'erb'
 require 'sprockets'
 
-
 module Jasmine
   module Headless
+    class IndexHandler
+      class << self
+        attr_accessor :index
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env['PATH_INFO'] == '/'
+          return [ 302, { 'Location' => self.class.index }, [ 'Redirecting...' ] ]
+        end
+
+        @app.call(env)
+      end
+    end
+
     class Runner
       JASMINE_DEFAULTS = {
         'spec_files' => [ '**/*[sS]pec.js' ],
@@ -25,22 +43,109 @@ module Jasmine
 
       attr_reader :options
 
-      class << self
-        def run(options = {})
-          options = Options.new(options) if !options.kind_of?(Options)
-          new(options).run
-        end
+      def self.run(options = {})
+        new(options).run
       end
 
-      def initialize(options)
-        if !File.file?(RUNNER)
-          $stderr.puts "No runner found, attempting to compile..."
-          Dir.chdir RUNNER_DIR do
-            system %{ruby extconf.rb}
+      def self.server_port
+        return @server_port if @server_port
+
+        require 'socket'
+
+        count = 100
+        begin
+          port = select_server_port
+
+          socket = TCPSocket.new(server_interface, port)
+          socket.close
+
+          count -= 1
+
+          raise "Could not create server port after 100 attempts!" if count == 0
+        rescue Errno::ECONNREFUSED
+          @server_port = port
+
+          break
+        ensure
+          begin
+            socket.close if socket
+          rescue IOError
+          end
+        end while true
+
+        @server_port
+      end
+
+      def self.server_port=(port)
+        @server_port = port
+      end
+
+      def self.select_server_port
+        21000 + rand(10000)
+      end
+
+      def self.server_interface
+        '127.0.0.1'
+      end
+
+      def self.server_uri
+        "http://#{server_interface}:#{server_port}"
+      end
+
+      def self.server_spec_path
+        self.server_uri + '/__JHW__/'
+      end
+
+      def self.ensure_server(options)
+        return if @server
+
+        require 'webrick'
+        require 'thread'
+        require 'rack'
+        require 'net/http'
+
+        port = server_port
+
+        @server = Thread.new do
+          Jasmine::Headless.warn "Powering up!"
+
+          app = Rack::Builder.new do
+            use IndexHandler
+
+            map '/__JHW__' do
+              run Rack::File.new(Dir.pwd)
+            end
+
+            map '/' do
+              run Rack::File.new('/')
+            end
           end
-          raise NoRunnerError if !File.file?(RUNNER)
+
+          Rack::Handler::WEBrick.run(
+            app,
+            :Port => port,
+            :Logger => Logger.new(StringIO.new),
+            :AccessLog => [
+              [ StringIO.new, WEBrick::AccessLog::COMMON_LOG_FORMAT ],
+              [ StringIO.new, WEBrick::AccessLog::REFERER_LOG_FORMAT ]
+            ]
+          )
         end
 
+        while true do
+          begin
+            Net::HTTP.get(URI(server_uri))
+            break
+          rescue Errno::ECONNREFUSED => e
+          end
+
+          sleep 0.1
+        end
+      end
+
+      def initialize(options)
+        options = Options.new(options) if !options.kind_of?(Options)
+
         @options = options
       end
 
@@ -59,27 +164,30 @@ module Jasmine
       end
 
       def jasmine_command(*targets)
-        [
-          RUNNER,
-          @options[:colors] ? '-c' : nil,
-          @options[:report] ? "-r #{@options[:report]}" : nil,
-          *targets
-        ].compact.join(" ")
+        command = [ RUNNER ]
+
+        command << "-s #{options[:seed]}"
+        command << '-c' if options[:colors]
+        command << '-q' if options[:quiet]
+
+        options.file_reporters.each do |reporter, identifier, file|
+          command << "-r #{file}"
+        end
+
+        command += targets
+        command.compact.join(' ')
       end
 
       def run
         Jasmine::Headless::CacheableAction.enabled = @options[:enable_cache]
+        Jasmine::Headless.show_warnings = !@options[:quiet]
         FilesList.reset!
 
-        files_list = Jasmine::Headless::FilesList.new(
-          :config => jasmine_config,
-          :only => @options[:files],
-          :seed => @options[:seed]
-        )
+        self.class.server_port = options[:server_port]
 
-        @_targets = template_writer.write!(files_list)
+        @_targets = template_writer.write
 
-        run_targets = @_targets.dup
+        run_targets = absolute_run_targets(@_targets.dup)
 
         if run_targets.length == 2
           if (!@options[:full_run] && files_list.filtered?) || files_list.has_spec_outside_scope?
@@ -87,9 +195,13 @@ module Jasmine
           end
         end
 
-        system jasmine_command(run_targets)
+        runner = lambda { system jasmine_command(run_targets) }
 
-        puts "\nTest ordering seed: --seed #{@options[:seed]}"
+        if options[:use_server]
+          wrap_in_server(run_targets, &runner)
+        else
+          runner.call
+        end
 
         @_status = $?.exitstatus
       ensure
@@ -98,6 +210,17 @@ module Jasmine
         end
       end
 
+      def absolute_run_targets(targets)
+        targets.flatten.collect do |target|
+          if options[:use_server]
+            target = self.class.server_spec_path + target
+          else
+            target = "file://" + File.expand_path(target)
+          end
+          target
+        end
+      end
+
       def runner_filename
         options[:runner_output_filename] || begin
           if (runner_output = jasmine_config['runner_output']) && !runner_output.empty?
@@ -108,11 +231,29 @@ module Jasmine
         end
       end
 
+      def files_list
+        @files_list ||= Jasmine::Headless::FilesList.new(
+          :config => jasmine_config,
+          :only => options[:files],
+          :seed => options[:seed],
+          :reporters => options.reporters
+        )
+      end
+
+      def wrap_in_server(run_targets)
+        self.class.ensure_server(options)
+        IndexHandler.index = run_targets.last
+
+        Jasmine::Headless.warn "HTTP powered specs! Located at #{run_targets.join(' ')}"
+
+        yield
+      end
+
       private
       def jasmine_config_data
         raise JasmineConfigNotFound.new("Jasmine config not found. I tried #{@options[:jasmine_config]}.") if !File.file?(@options[:jasmine_config])
 
-        YAML.load_file(@options[:jasmine_config])
+        YAML.load(ERB.new(File.read(@options[:jasmine_config])).result(binding))
       end
     end
   end

data/lib/jasmine/headless/task.rb

@@ -14,23 +14,9 @@ module Jasmine
 
         desc 'Run Jasmine specs headlessly'
         task(name) { run_rake_task }
-
-        create_rails_compliant_task if defined?(Rails)
       end
 
       private
-      def create_rails_compliant_task
-        if Rails.respond_to?(:version) && Rails.version >= "3.1.0"
-          task 'assets:precompile:for_testing' => :environment do
-            $stderr.puts "This task is deprecated and will be removed after 2012-01-01"
-
-            Rails.application.assets.digest_class = Digest::JasmineTest
-
-            Rake::Task['assets:precompile'].invoke
-          end
-        end
-      end
-
       def run_rake_task
         case Jasmine::Headless::Runner.run(
           :colors => colors,

data/lib/jasmine/headless/template_writer.rb

@@ -1,24 +1,32 @@
 require 'multi_json'
 require 'erb'
 require 'tempfile'
+require 'forwardable'
 
 module Jasmine::Headless
   class TemplateWriter
     attr_reader :runner
 
+    extend Forwardable
+
+    def_delegators :runner, :files_list, :options
+    def_delegators :options, :reporters
+
     def initialize(runner)
       @runner = runner
     end
 
-    def write!(files_list)
+    def write
       output = [
         [ all_tests_filename, files_list.files_to_html ]
       ]
 
-      output.unshift([filtered_tests_filename , files_list.filtered_files_to_html ]) if files_list.filtered?
+      output.unshift([filtered_tests_filename, files_list.filtered_files_to_html ]) if files_list.filtered?
 
       output.each do |name, files|
-        File.open(name, 'w') { |fh| fh.print template_for(files, files_list.spec_file_line_numbers) }
+        template = template_for(files)
+
+        File.open(name, 'wb') { |fh| fh.print template }
       end
 
       output.collect(&:first)
@@ -32,8 +40,24 @@ module Jasmine::Headless
       all_tests_filename.gsub(%r{\.html$}, '.filter.html')
     end
 
+    def render
+      template_for(all_files)
+    end
+
+    def all_files
+      files_list.files_to_html
+    end
+
+    def jhw_reporters
+      reporters.collect do |reporter, output|
+        %{jasmine.getEnv().addReporter(new jasmine.HeadlessReporter.#{reporter}("#{output}"));}
+      end.join("\n")
+    end
+
     private
-    def template_for(files, spec_lines)
+    def template_for(files)
+      spec_lines = files_list.spec_file_line_numbers
+
       ERB.new(Jasmine::Headless.root.join('skel/template.html.erb').read).result(binding)
     end
   end

data/lib/jasmine/headless/unique_asset_list.rb

@@ -3,7 +3,7 @@ module Jasmine::Headless
     def <<(asset)
       raise InvalidUniqueAsset.new("Not an asset: #{asset.inspect}") if !asset.respond_to?(:logical_path)
 
-      super if !self.any? { |other| asset.logical_path == other.logical_path }
+      super if !self.any? { |other| asset.pathname == other.pathname }
     end
 
     def flatten

data/lib/jasmine/headless/version.rb

@@ -1,5 +1,5 @@
 module Jasmine
   module Headless
-    VERSION = "0.8.4"
+    VERSION = "0.9.0.rc1"
   end
 end

data/lib/jasmine/headless.rb

@@ -35,6 +35,24 @@ module Jasmine
       def root
         @root ||= Pathname(File.expand_path('../../..', __FILE__))
       end
+
+      def warn(message)
+        output.puts message if show_warnings?
+      end
+
+      def show_warnings=(show)
+        @show_warnings = show
+      end
+
+      def show_warnings?
+        @show_warnings = true if @show_warnings.nil?
+
+        @show_warnings
+      end
+
+      def output
+        $stdout
+      end
     end
   end
 end

data/lib/jasmine-headless-webkit.rb

@@ -1,7 +1,3 @@
 require 'jasmine/headless'
 require 'jasmine/headless/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
 
-module Digest
-  autoload :JasmineTest, 'digest/jasmine_test'
-end
-

data/script/hooks/post-commit

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+penchant gemfile remote --switch-back
+

data/script/hooks/pre-commit

@@ -2,9 +2,9 @@
 
 OLD_GIT_DIR=$GIT_DIR
 
-if [ "$(penchant gemfile-env)" != "remote" ]; then
+if [ "$(penchant gemfile-env)" != "remote deployment" ]; then
   unset GIT_DIR
-  penchant gemfile remote
+  penchant gemfile remote --deployment
   GIT_DIR=$OLD_GIT_DIR
   git add Gemfile*
 fi

data/script/initialize-environment

@@ -5,7 +5,7 @@ if File.file?('Gemfile.erb')
 
   Dir.chdir '..' do
     File.readlines(File.join(pwd, 'Gemfile.erb')).find_all { |line| line[':git'] }.each do |line|
-      repo = line[%r{:git => (['"])(.*)\1}, 2]
+      repo = line[%r{:git => (['"])([^'"]+)\1}, 2]
 
       puts "Installing #{repo}"
       system %{git clone #{repo}}

data/skel/template.html.erb

@@ -12,7 +12,7 @@
   <body>
     <script type="text/javascript">
       jasmine.getEnv().console = {
-        log: function(msg) { JHW.stdout.puts(msg) }
+        log: function(msg) { JHW.print('stdout', msg + "\n"); }
       }
 
       window._onload = window.onload;
@@ -23,7 +23,7 @@
         }
 
         if (window.JHW) {
-          jasmine.getEnv().addReporter(new jasmine.HeadlessConsoleReporter());
+          <%= jhw_reporters %>
         } else {
           types = [ 'HtmlReporter', 'TrivialReporter' ];
 
@@ -34,6 +34,35 @@
               break;
             }
           }
+
+          var getLastModified = function(callback) {
+            var http = new XMLHttpRequest();
+            var header;
+
+            http.open('HEAD', window.location.href, false);
+
+            http.onreadystatechange = function() {
+              callback(http.getResponseHeader('Last-Modified'));
+            };
+            http.send();
+          }
+
+          getLastModified(function(currentLastModified) {
+            var checker;
+            checker = function() {
+              setTimeout(function() {
+                getLastModified(function(newLastModified) {
+                  if (currentLastModified != newLastModified) {
+                    setTimeout(function() { window.location.reload(); }, 1000);
+                  } else {
+                    checker();
+                  }
+                });
+              }, 3000);
+            };
+
+            checker();
+          });
         }
 
         jasmine.getEnv().execute();

data/spec/jasmine/noisy/noisy.yml

@@ -0,0 +1,8 @@
+src_dir: spec/jasmine/noisy
+src_files:
+- '**/*'
+
+spec_dir: spec/jasmine/noisy
+spec_files:
+- '**/*'
+

data/spec/jasmine/noisy/other_file.js

@@ -0,0 +1,2 @@
+window.prompt("hello");
+

data/spec/jasmine/two_files_from_src_files/app/app.js

@@ -0,0 +1,2 @@
+//= require app-file
+//

data/spec/jasmine/two_files_from_src_files/jasmine.yml

@@ -0,0 +1,7 @@
+src_dir: spec/jasmine/two_files_from_src_files/app
+
+asset_paths:
+- "spec/jasmine/two_files_from_src_files/vendor"
+
+src_files: [ 'vendor.js', 'app.js' ]
+

data/spec/jasmine/two_files_from_src_files/vendor/vendor.js

@@ -0,0 +1,2 @@
+//= require vendor-file
+//

data/spec/jasmine/two_spec_files_same_basename/jasmine.yml

@@ -0,0 +1,6 @@
+src_dir: spec/jasmine/two_spec_files_same_basename
+src_files: []
+
+spec_dir: spec/jasmine/two_spec_files_same_basename
+spec_files: [ "**/*.{js,coffee}" ]
+

data/spec/jasmine/two_spec_files_same_basename/spec.coffee

@@ -0,0 +1,4 @@
+describe 'two', ->
+  it 'should pass', ->
+    expect(true).toEqual(true)
+

data/spec/jasmine/two_spec_files_same_basename/spec.js

@@ -0,0 +1,6 @@
+describe("one", function() {
+  it('should pass', function() {
+    expect(true).toEqual(true);
+  });
+});
+

data/spec/jasmine/window_prompt/source.js

@@ -0,0 +1,2 @@
+window.prompt("Yes! Hi!");
+

data/spec/jasmine/window_prompt/window_prompt.yml

@@ -0,0 +1,4 @@
+src_dir: spec/jasmine/window_prompt
+src_files: 
+- '**/*.js'
+

data/spec/javascripts/headless_reporter_result_spec.coffee

@@ -4,11 +4,27 @@ describe 'HeadlessReporterResult', ->
   splitName = "splitName"
   message = 'message'
 
-  beforeEach ->
-    result = new HeadlessReporterResult(name, splitName)
+  context 'no lines', ->
+    beforeEach ->
+      result = new HeadlessReporterResult(name, splitName)
 
-  describe '#addResult', ->
-    it 'should add a message', ->
-      result.addResult(message)
+    describe '#addResult', ->
+      it 'should add a message', ->
+        result.addResult(message)
+
+        expect(result.results).toEqual([ message ])
+
+  context 'with lines', ->
+    beforeEach ->
+      HeadlessReporterResult.specLineNumbers = {
+        'one': {
+          'name': [ 1 ],
+          'of': [ 2, 9 ],
+          'test': [ 3, 10 ],
+          'other': [ 7 ]
+        }
+      }
+    it 'should find the best spec lines', ->
+      expect(HeadlessReporterResult.findSpecLine([ 'name', 'of', 'test' ]).lineNumber).toEqual(3)
+      expect(HeadlessReporterResult.findSpecLine([ 'other', 'of', 'test' ]).lineNumber).toEqual(10)
 
-      expect(result.results).toEqual([ message ])

data/spec/javascripts/helpers/spec_helper.coffee

@@ -0,0 +1,2 @@
+window.context = window.describe
+

data/spec/javascripts/{jasmine.HeadlessConsoleReporter_spec.coffee → jasmine-extensions_spec.coffee}

@@ -1,38 +1,3 @@
-describe 'HeadlessReporterResult', ->
-  beforeEach ->
-    HeadlessReporterResult.specLineNumbers = {
-      'one': {
-        'name': [ 1 ],
-        'of': [ 2, 9 ],
-        'test': [ 3, 10 ],
-        'other': [ 7 ]
-      }
-    }
-  it 'should find the best spec lines', ->
-    expect(HeadlessReporterResult.findSpecLine([ 'name', 'of', 'test' ]).lineNumber).toEqual(3)
-    expect(HeadlessReporterResult.findSpecLine([ 'other', 'of', 'test' ]).lineNumber).toEqual(10)
-
-describe 'jasmine.HeadlessConsoleReporter', ->
-  reporter = null
-
-  beforeEach ->
-    reporter = new jasmine.HeadlessConsoleReporter()
-
-  it 'should stop running specs if there are errors reported', ->
-    # otherwise it gets really confusing!
-
-    suite = { finish: -> null }
-    spec = new jasmine.Spec("env", suite, "test")
-
-    spyOn(reporter, 'hasError').andReturn(true)
-    spyOn(spec, 'finish')
-    spyOn(suite, 'finish')
-
-    reporter.reportSpecStarting(spec)
-    
-    expect(spec.finish).toHaveBeenCalled()
-    expect(suite.finish).toHaveBeenCalled()
-
 describe 'jasmine.Suite.prototype.getSuiteSplitName', ->
   it 'should flatten the description', ->
     suite = new jasmine.Suite({});

data/spec/javascripts/jasmine.HeadlessReporter.ConsoleBase_spec.coffee

@@ -0,0 +1,35 @@
+describe 'jasmine.HeadlessReporter.ConsoleBase', ->
+  reporter = null
+
+  beforeEach ->
+    reporter = new jasmine.HeadlessReporter.ConsoleBase()
+
+  describe '#formatResultLine', ->
+    context 'length = 1', ->
+      it 'should format', ->
+        reporter.length = 1
+        expect(reporter.formatResultLine(0)).toMatch(/test,/)
+
+    context 'length != 1', ->
+      it 'should format', ->
+        reporter.length = 2
+        expect(reporter.formatResultLine(0)).toMatch(/tests,/)
+
+    context 'failedCount = 1', ->
+      it 'should format', ->
+        reporter.failedCount = 1
+        expect(reporter.formatResultLine(0)).toMatch(/failure,/)
+
+    context 'failedCount != 1', ->
+      it 'should format', ->
+        reporter.failedCount = 0
+        expect(reporter.formatResultLine(0)).toMatch(/failures,/)
+
+    context 'runtime = 1', ->
+      it 'should format', ->
+        expect(reporter.formatResultLine(1)).toMatch(/sec./)
+
+    context 'runtime != 1', ->
+      it 'should format', ->
+        expect(reporter.formatResultLine(0)).toMatch(/secs./)
+

data/spec/javascripts/jasmine.HeadlessReporter.Console_spec.coffee

@@ -0,0 +1,3 @@
+describe 'jasmine.HeadlessReporter.Console', ->
+  describe '#reportSpecResults', ->
+