jasmine 2.0.0 → 2.99.0

data/lib/jasmine/configuration.rb

@@ -1,25 +1,44 @@
 module Jasmine
   class Configuration
     attr_writer :jasmine_css_files, :css_files
-    attr_writer :jasmine_files, :boot_files, :src_files, :spec_files
-    attr_accessor :jasmine_path, :spec_path, :boot_path, :src_path, :image_path
-    attr_accessor :jasmine_dir, :spec_dir, :boot_dir, :src_dir, :images_dir
+    attr_writer :jasmine_files, :boot_files, :src_files, :runner_boot_files
+    attr_accessor :helper_files, :spec_files
+    attr_accessor :jasmine_path, :spec_path, :boot_path, :src_path, :image_path, :runner_boot_path
+    attr_accessor :jasmine_dir, :spec_dir, :boot_dir, :src_dir, :images_dir, :runner_boot_dir
     attr_accessor :formatters
     attr_accessor :host
     attr_accessor :spec_format
     attr_accessor :runner
+    attr_accessor :rack_options
+    attr_accessor :prevent_phantom_js_auto_install
+    attr_accessor :show_console_log
+    attr_accessor :stop_spec_on_expectation_failure
+    attr_accessor :random
+    attr_accessor :phantom_config_script
+    attr_accessor :phantom_cli_options
+    attr_accessor :show_full_stack_trace
+    attr_reader :rack_apps
 
     def initialize()
       @rack_paths = {}
-      @apps = []
+      @rack_apps = []
       @path_mappers = []
       @jasmine_css_files = lambda { [] }
       @css_files = lambda { [] }
       @jasmine_files = lambda { [] }
       @boot_files = lambda { [] }
+      @runner_boot_files = lambda { [] }
       @src_files = lambda { [] }
+      @helper_files = lambda { [] }
       @spec_files = lambda { [] }
+      @testing_files = lambda { helper_files.call + spec_files.call}
       @runner = lambda { |config| }
+      @rack_options = {}
+      @show_console_log = false
+      @stop_spec_on_expectation_failure = false
+      @random = false
+      @phantom_config_script = nil
+      @phantom_cli_options = {}
 
       @formatters = [Jasmine::Formatters::Console]
 
@@ -34,8 +53,9 @@ module Jasmine
     def js_files
       map(@jasmine_files, :jasmine) +
         map(@boot_files, :boot) +
+        map(@runner_boot_files, :runner_boot) +
         map(@src_files, :src) +
-        map(@spec_files, :spec)
+        map(@testing_files, :spec)
     end
 
     def rack_path_map
@@ -46,12 +66,12 @@ module Jasmine
       @rack_paths[path] = rack_app_lambda
     end
 
-    def rack_apps
-      [] + @apps
-    end
-
-    def add_rack_app(app, &block)
-      @apps << [app, block]
+    def add_rack_app(app, *args, &block)
+      @rack_apps << {
+          :app => app,
+          :args => args,
+          :block => block
+      }
     end
 
     def add_path_mapper(mapper)

data/lib/jasmine/dependencies.rb

@@ -3,55 +3,26 @@ module Jasmine
 
     class << self
       def rails3?
-        safe_gem_check("rails", "~> 3") && running_rails3?
+        rails? && Rails.version.to_i == 3
       end
 
       def rails4?
-        safe_gem_check("rails", "~> 4.0.0.rc1") && running_rails4?
+        rails? && Rails.version.to_i == 4
       end
 
-      def rails?
-        rails_available? && running_rails?
-      end
-
-      def rails_available?
-        safe_gem_check("rails", '>= 3')
+      def rails5?
+        rails? && Rails.version.to_i == 5
       end
 
-      def legacy_rack?
-        !defined?(Rack::Server)
+      def rails?
+        defined?(Rails) && Rails.respond_to?(:version)
       end
 
       def use_asset_pipeline?
-        assets_pipeline_available = (rails3? || rails4?) && Rails.respond_to?(:application) && Rails.application.respond_to?(:assets)
+        assets_pipeline_available = (rails3? || rails4? || rails5?) && Rails.respond_to?(:application) && Rails.application.respond_to?(:assets) && !Rails.application.assets.nil?
         rails3_assets_enabled = rails3? && assets_pipeline_available && Rails.application.config.assets.enabled != false
-        assets_pipeline_available && (rails4? || rails3_assets_enabled)
-      end
-
-      private
-
-      def running_rails3?
-        running_rails? && Rails.version.to_i == 3
+        assets_pipeline_available && (rails4? || rails5? || rails3_assets_enabled)
       end
-
-      def running_rails4?
-        running_rails? && Rails.version.to_i == 4
-      end
-
-      def running_rails?
-        defined?(Rails) && Rails.respond_to?(:version)
-      end
-
-      def safe_gem_check(gem_name, version_string)
-        if Gem::Specification.respond_to?(:find_by_name)
-          Gem::Specification.find_by_name(gem_name, version_string)
-        elsif Gem.respond_to?(:available?)
-          Gem.available?(gem_name, version_string)
-        end
-      rescue Gem::LoadError
-        false
-      end
-
     end
   end
 end

data/lib/jasmine/formatters/console.rb

@@ -1,25 +1,52 @@
 module Jasmine
   module Formatters
     class Console
-      def initialize(outputter = Kernel.method(:puts))
+      def initialize(outputter = Kernel)
         @results = []
         @outputter = outputter
       end
 
       def format(results_batch)
-        outputter.call(failures(results_batch))
+        outputter.print(chars(results_batch))
         @results += results_batch
       end
 
-      def done
+      def done(run_details)
+        outputter.puts
+
+        run_result = global_failure_details(run_details)
+
         failure_count = results.count(&:failed?)
+        if failure_count > 0
+          outputter.puts('Failures:')
+          outputter.puts(failures(@results))
+          outputter.puts
+        end
+
         pending_count = results.count(&:pending?)
+        if pending_count > 0
+          outputter.puts('Pending:')
+          outputter.puts(pending(@results))
+          outputter.puts
+        end
+
+        deprecationWarnings = (@results + [run_result]).map(&:deprecation_warnings).flatten
+        if deprecationWarnings.size > 0
+          outputter.puts('Deprecations:')
+          outputter.puts(deprecations(deprecationWarnings))
+          outputter.puts
+        end
+
         summary = "#{pluralize(results.size, 'spec')}, " +
           "#{pluralize(failure_count, 'failure')}"
 
         summary += ", #{pluralize(pending_count, 'pending spec')}" if pending_count > 0
 
-        outputter.call(summary)
+        outputter.puts(summary)
+
+        if run_details['order'] && run_details['order']['random']
+          outputter.puts("Randomized with seed #{run_details['order']['seed']}")
+        end
       end
 
       private
@@ -29,11 +56,49 @@ module Jasmine
         results.select(&:failed?).map { |f| failure_message(f) }.join("\n\n")
       end
 
+      def pending(results)
+        results.select(&:pending?).map { |spec| pending_message(spec) }.join("\n\n")
+      end
+
+      def deprecations(warnings)
+        warnings.map { |w| expectation_message(w) }.join("\n\n")
+      end
+
+      def global_failure_details(run_details)
+        result = Jasmine::Result.new(run_details.merge('fullName' => 'Error occurred in afterAll', 'description' => ''))
+        if (result.failed_expectations.size > 0)
+          outputter.puts(failure_message(result))
+          outputter.puts
+        end
+        result
+      end
+
+      def chars(results)
+        results.map do |result|
+          if result.succeeded?
+            "\e[32m.\e[0m"
+          elsif result.pending?
+            "\e[33m*\e[0m"
+          elsif result.disabled?
+            ""
+          else
+            "\e[31mF\e[0m"
+          end
+        end.join('')
+      end
+
       def pluralize(count, str)
         word = (count == 1) ? str : str + 's'
         "#{count} #{word}"
       end
 
+      def pending_message(spec)
+        reason = 'No reason given'
+        reason = spec.pending_reason if spec.pending_reason && spec.pending_reason != ''
+
+        "\t#{spec.full_name}\n\t  \e[33m#{reason}\e[0m"
+      end
+
       def failure_message(failure)
         template = <<-FM
           #{failure.full_name}\n

data/lib/jasmine/formatters/exit_code.rb

@@ -3,21 +3,19 @@ module Jasmine
     class ExitCode
       def initialize
         @results = []
+        @global_failure = false
       end
 
       def format(results)
         @results += results
       end
 
-      def done
-      end
-
-      def exit_code
-        @results.detect(&:failed?) ? 1 : 0
+      def done(details)
+        @global_failure = details.fetch('failedExpectations', []).size > 0
       end
 
       def succeeded?
-        !@results.detect(&:failed?)
+        !@results.detect(&:failed?) && !@global_failure
       end
     end
   end

data/lib/jasmine/formatters/multi.rb

@@ -6,19 +6,11 @@ module Jasmine
       end
 
       def format(results)
-        go(:format, results)
+        @formatters.each { |formatter| formatter.format(results) }
       end
 
-      def done
-        go(:done)
-      end
-
-      private
-
-      def go(method, *args)
-        (@formatters || []).each do |formatter|
-          formatter.public_send(method, *args)
-        end
+      def done(details = {})
+        @formatters.each { |formatter| formatter.done(details) }
       end
     end
   end

data/lib/jasmine/path_expander.rb

@@ -7,7 +7,11 @@ module Jasmine
         patterns.map do |path|
           files = globber.call(File.join(base_directory, path.gsub(/^!/, '')))
           if files.empty? && !(path =~ /\*|^\!/)
-            files = [File.join(base_directory, path)]
+            if path[0..3] == 'http'
+              files << path
+            else
+              files = [File.join(base_directory, path)]
+            end
           end
           files.sort
         end.flatten.uniq

data/lib/jasmine/path_mapper.rb

@@ -16,14 +16,23 @@ module Jasmine
       map(paths, @config.boot_dir, @config.boot_path)
     end
 
+    def map_runner_boot_paths(paths)
+      map(paths, @config.runner_boot_dir, @config.runner_boot_path)
+    end
+
     def map_jasmine_paths(paths)
       map(paths, @config.jasmine_dir, @config.jasmine_path)
     end
 
     private
     def map(paths, remove_path, add_path)
-      paths.map { |path| File.join(add_path, (path.gsub(remove_path, ''))) }
+      paths.map do |path|
+        if path[0..3] == 'http'
+          path
+        else
+          File.join(add_path, (path.sub(remove_path, '')))
+        end
+      end
     end
-
   end
 end

data/lib/jasmine/railtie.rb

@@ -3,7 +3,7 @@ require 'rails/railtie'
 module Jasmine
   class Railtie < Rails::Railtie
 
-    config.before_configuration do
+    initializer "jasmine.initializer", :before => :load_environment_hook do
       old_jasmine_rakefile = ::Rails.root.join('lib', 'tasks', 'jasmine.rake')
       if old_jasmine_rakefile.exist? && !ENV['USE_JASMINE_RAKE']
         puts '

data/lib/jasmine/result.rb

@@ -6,11 +6,14 @@ module Jasmine
     end
 
     def initialize(attrs)
+      @show_full_stack_trace = attrs["show_full_stack_trace"]
       @status = attrs["status"]
       @full_name = attrs["fullName"]
       @description = attrs["description"]
-      @failed_expectations = map_failures(attrs["failedExpectations"])
+      @failed_expectations = map_failures(attrs.fetch("failedExpectations", []))
+      @deprecation_warnings = map_failures(attrs.fetch("deprecationWarnings", []))
       @suite_name = full_name.slice(0, full_name.size - description.size - 1)
+      @pending_reason = attrs["pendingReason"]
     end
 
     def succeeded?
@@ -25,19 +28,28 @@ module Jasmine
       status == 'pending'
     end
 
-    attr_reader :full_name, :description, :failed_expectations, :suite_name
+    def disabled?
+      status == 'disabled'
+    end
+
+    attr_reader :full_name, :description, :failed_expectations, :deprecation_warnings, :suite_name, :pending_reason
 
     private
-    attr_reader :status
+    attr_reader :status, :show_full_stack_trace
 
     def map_failures(failures)
       failures.map do |e|
-        short_stack = if e["stack"]
-                        e["stack"].split("\n").slice(0, 7).join("\n")
-                      else
-                        "No stack trace present."
-                      end
-        Failure.new(e["message"], short_stack)
+        if e["stack"]
+          if show_full_stack_trace
+            stack = e["stack"]
+          else
+            stack = e["stack"].split("\n").slice(0, 7).join("\n")
+          end
+        else
+          stack = "No stack trace present."
+        end
+
+        Failure.new(e["message"], stack)
       end
     end
 

data/lib/jasmine/ruby_versions.rb

@@ -0,0 +1,11 @@
+def ruby_version_less_than(target_version)
+  version_parts = RUBY_VERSION.split('.').map(&:to_i).zip(target_version)
+
+  version_parts.each do |(current_part, target_part)|
+    if current_part < target_part
+      return true
+    end
+  end
+  false
+end
+

data/lib/jasmine/run.html.erb

@@ -14,7 +14,7 @@
 
 </head>
 <!-- TODO: turbolinks breaks spec filter links -->
-<body data-no-turbolink>
+<body data-no-turbolink data-turbolinks="false">
 <div id="jasmine_content"></div>
 </body>
 </html>

data/lib/jasmine/runners/phantom_boot.js

@@ -0,0 +1,15 @@
+function PhantomReporter() {
+  this.jasmineDone = function(details) {
+    window.callPhantom({ state: 'jasmineDone', details: details });
+  };
+
+  this.specDone = function(results) {
+    window.callPhantom({ state: 'specDone', results: results });
+  };
+
+  this.suiteDone = function(results) {
+    window.callPhantom({ state: 'suiteDone', results: results });
+  };
+}
+
+jasmine.getEnv().addReporter(new PhantomReporter());

data/lib/jasmine/runners/phantom_jasmine_run.js

@@ -1,54 +1,50 @@
 (function() {
-  /**
-   * Wait until the test condition is true or a timeout occurs. Useful for waiting
-   * on a server response or for a ui change (fadeIn, etc.) to occur.
-   *
-   * @param testFx javascript condition that evaluates to a boolean,
-   * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
-   * as a callback function.
-   * @param onReady what to do when testFx condition is fulfilled,
-   * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
-   * as a callback function.
-   */
-  function waitFor(testFx, onReady) {
-    var condition = false,
-    interval = setInterval(function() {
-      if (!condition) {
-        condition = (typeof(testFx) === 'string' ? eval(testFx) : testFx());
-      } else {
-        if (typeof(onReady) === 'string') {
-          eval(onReady);
-        } else {
-          onReady();
-        }
-        clearInterval(interval);
-      }
-    }, 100);
+
+  if (phantom.version.major >= 2) {
+    var system = require('system');
+    var url = system.args[1];
+    var showConsoleLog = system.args[2] === 'true';
+    var configScript = system.args[3];
+  }
+  else {
+    var url = phantom.args[0];
+    var showConsoleLog = phantom.args[1] === 'true';
+    var configScript = phantom.args[2];
   }
 
-  var url = phantom.args[0];
-  var batchSize = parseInt(phantom.args[1], 10);
   var page = require('webpage').create();
+  configScript = configScript.replace(/['"]{2}/,"");
+  
+  if (configScript !== '') {
+    try {
+      require(configScript).configure(page);
+    } catch(e) {
+      console.error('Failed to configure phantom');
+      console.error(e.stack);
+      phantom.exit(1);
+    }
+  }
+
+  page.onCallback = function(data) {
+    if(data.state === 'specDone') {
+      console.log('jasmine_spec_result' + JSON.stringify([].concat(data.results)));
+    } else if (data.state === 'suiteDone') {
+      console.log('jasmine_suite_result' + JSON.stringify([].concat(data.results)));
+    } else {
+      console.log('jasmine_done' + JSON.stringify(data.details));
+      phantom.exit(0);
+    }
+  };
+
+  if (showConsoleLog) {
+    page.onConsoleMessage = function(message) {
+      console.log(message);
+    };
+  }
 
   page.open(url, function(status) {
     if (status !== "success") {
       phantom.exit(1);
-    } else {
-      waitFor(function() {
-        return page.evaluate(function() {
-          return jsApiReporter && jsApiReporter.finished
-        });
-      }, function() {
-        var index = 0, results;
-        do {
-          results = page.evaluate(function(index, batchSize) {
-            return jsApiReporter.specResults(index, batchSize)
-          }, index, batchSize);
-          console.log(JSON.stringify(results));
-          index += batchSize;
-        } while (results && results.length == batchSize)
-        phantom.exit(0);
-      });
     }
   });
 }).call(this);

data/lib/jasmine/runners/phantom_js.rb

@@ -3,26 +3,71 @@ require 'phantomjs'
 module Jasmine
   module Runners
     class PhantomJs
-      def initialize(formatter, jasmine_server_url, result_batch_size)
+      def initialize(formatter, jasmine_server_url, prevent_phantom_js_auto_install, show_console_log, phantom_config_script, show_full_stack_trace, cli_options = nil)
         @formatter = formatter
         @jasmine_server_url = jasmine_server_url
-        @result_batch_size = result_batch_size
+        @prevent_phantom_js_auto_install = prevent_phantom_js_auto_install
+        @show_console_log = show_console_log
+        @phantom_config_script = phantom_config_script
+        @show_full_stack_trace = show_full_stack_trace
+        @cli_options = cli_options || {}
       end
 
       def run
-        command = "#{Phantomjs.path} '#{File.join(File.dirname(__FILE__), 'phantom_jasmine_run.js')}' #{jasmine_server_url} #{result_batch_size}"
+        phantom_script = File.join(File.dirname(__FILE__), 'phantom_jasmine_run.js')
+        command = "\"#{phantom_js_path}\" \"#{cli_options_string}\" \"#{phantom_script}\" \"#{jasmine_server_url}\" \"#{show_console_log}\" \"#{@phantom_config_script}\""
+        run_details = { 'random' => false }
         IO.popen(command) do |output|
           output.each do |line|
-            raw_results = JSON.parse(line, :max_nesting => false)
-            results = raw_results.map { |r| Result.new(r) }
-            formatter.format(results)
+            if line =~ /^jasmine_spec_result/
+              line = line.sub(/^jasmine_spec_result/, '')
+              raw_results = JSON.parse(line, :max_nesting => false)
+              results = raw_results.map { |r| Result.new(r.merge!("show_full_stack_trace" => @show_full_stack_trace)) }
+              formatter.format(results)
+            elsif line =~ /^jasmine_suite_result/
+              line = line.sub(/^jasmine_suite_result/, '')
+              raw_results = JSON.parse(line, :max_nesting => false)
+              results = raw_results.map { |r| Result.new(r.merge!("show_full_stack_trace" => @show_full_stack_trace)) }
+              failures = results.select(&:failed?)
+              if failures.any?
+                formatter.format(failures)
+              end
+            elsif line =~ /^jasmine_done/
+              line = line.sub(/^jasmine_done/, '')
+              run_details = JSON.parse(line, :max_nesting => false)
+            elsif line =~ /^Failed to configure phantom$/
+              config_failure = Result.new('fullName' => line,
+                                          'failedExpectations' => [],
+                                          'description' => '',
+                                          'status' => 'failed',
+                                          'show_full_stack_trace' => @show_full_stack_trace)
+              formatter.format([config_failure])
+              @show_console_log = true
+              puts line
+            elsif show_console_log
+              puts line
+            end
           end
         end
-        formatter.done
+        formatter.done(run_details)
+      end
+
+      def phantom_js_path
+        prevent_phantom_js_auto_install ? 'phantomjs' : Phantomjs.path
+      end
+
+      def boot_js
+        File.expand_path('phantom_boot.js', File.dirname(__FILE__))
+      end
+
+      def cli_options_string
+        @cli_options.
+            map {|(k, v)| "--#{k}=#{v}"}.
+            join(' ')
       end
 
       private
-      attr_reader :formatter, :jasmine_server_url, :result_batch_size
+      attr_reader :formatter, :jasmine_server_url, :prevent_phantom_js_auto_install, :show_console_log
     end
   end
 end

data/lib/jasmine/server.rb

@@ -1,20 +1,17 @@
 module Jasmine
   class Server
-    def initialize(port = 8888, application = nil)
+    def initialize(port = 8888, application = nil, rack_options = nil, env = ENV)
       @port = port
       @application = application
+      @rack_options = rack_options || {}
+      @env = env
     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
+      @env['PORT'] = @port.to_s
+      Rack::Server.start(@rack_options.merge(:Port => @port,
+                                             :AccessLog => [],
+                                             :app => @application))
     end
   end
 end