jasmine-headless-webkit-firstbanco 0.9.0.rc.2

data/features/steps/given/options/i_have_runner_options.rb

@@ -0,0 +1,3 @@
+Given /^I have the following runner options:$/ do |string|
+  @options = YAML.load(string)
+end

data/features/steps/then/bin/exit_status_should_be.rb

@@ -0,0 +1,3 @@
+Then /^the exit status should be (\d+)$/ do |exitstatus|
+  $?.exitstatus.should == exitstatus.to_i
+end

data/features/steps/then/bin/file_should_contain_runner.rb

@@ -0,0 +1,4 @@
+Then /^the file "([^"]*)" should contain a JHW runner$/ do |file|
+  File.read(file).should include('jasmine.HeadlessReporter')
+end
+

data/features/steps/then/bin/following_files_loaded_in_order.rb

@@ -0,0 +1,10 @@
+Then /^the following files should be loaded in order:$/ do |table|
+  files = table.raw.flatten
+
+  @output.lines.collect(&:strip).each do |line|
+    files.shift if line[files.first]
+  end
+
+  files.should be_empty
+end
+

data/features/steps/then/bin/i_should_get_help_output.rb

@@ -0,0 +1,4 @@
+Then /^I should get help output$/ do
+  @output.should include("Usage:")
+end
+

data/features/steps/then/bin/output_should_include.rb

@@ -0,0 +1,3 @@
+Then /^the output should include "([^"]*)"$/ do |string|
+  @output.should include(string)
+end

data/features/steps/then/bin/output_should_not_include.rb

@@ -0,0 +1,4 @@
+Then /^the output should not include "([^"]*)"$/ do |string|
+  @output.should_not include(string)
+end
+

data/features/steps/then/reporting/report_does_not_exist.rb

@@ -0,0 +1,4 @@
+Then /^the report file "([^"]*)" should not exist$/ do |file|
+  File.file?(file).should be_false
+end
+

data/features/steps/then/reporting/report_should_exist.rb

@@ -0,0 +1,3 @@
+Then /^the report file "([^"]*)" should exist$/ do |file|
+  File.file?(file).should be_true
+end

data/features/steps/then/reporting/report_should_have.rb

@@ -0,0 +1,7 @@
+Then /^the report file "(.*)" should have (\d+) total, (\d+) failures?, (no|yes) console usage$/ do |file, total, failures, console_usage|
+  report = Jasmine::Headless::Report.load(file)
+
+  report.total.should == total.to_i
+  report.failed.should == failures.to_i
+  report.has_used_console?.should == (console_usage == 'yes')
+end

data/features/steps/then/reporting/report_should_have_seed.rb

@@ -0,0 +1,4 @@
+Then /^the report file "([^"]*)" should have seed (\d+)$/ do |file, seed|
+  report = Jasmine::Headless::Report.load(file)
+  report.seed.should == seed.to_i
+end

data/features/steps/then/runner/it_should_have_exit_status.rb

@@ -0,0 +1,3 @@
+Then /^the runner should have an exit status of (\d+)$/ do |exit_status|
+  @result.should == exit_status.to_i
+end

data/features/steps/then/runner/it_should_include_report_file.rb

@@ -0,0 +1,4 @@
+Then /^the command to run the runner should include the report file "([^"]*)"$/ do |file|
+  @runner.jasmine_command.should include("-r #{file}")
+end
+

data/features/steps/then/runner/it_should_not_include_report_file.rb

@@ -0,0 +1,3 @@
+Then /^the command to run the runner should not include a report file$/ do
+  @runner.jasmine_command.should_not include('-r')
+end

data/features/steps/then/templates/it_should_use_reporter.rb

@@ -0,0 +1,6 @@
+Then /^the template should use the "([^"]*)" reporter to "([^"]*)"$/ do |reporter, target|
+  output = @template_writer.render
+
+  output.should include(%{jasmine.HeadlessReporter.#{reporter}("#{target}")})
+end
+

data/features/steps/when/i_delete_file.rb

@@ -0,0 +1,3 @@
+When /^I delete the file "([^"]*)"$/ do |file|
+  FileUtils.rm_f(file)
+end

data/features/steps/when/i_get_runner.rb

@@ -0,0 +1,4 @@
+When /^I get a runner$/ do
+  @runner = Jasmine::Headless::Runner.new(@options)
+end
+

data/features/steps/when/i_get_template_writer.rb

@@ -0,0 +1,4 @@
+When /^I get a template writer$/ do
+  @template_writer = Jasmine::Headless::TemplateWriter.new(@runner)
+end
+

data/features/steps/when/i_run_executable.rb

@@ -0,0 +1,4 @@
+When /^I run `(.*)`$/ do |command|
+  @output = `#{command}`
+end
+

data/features/steps/when/i_run_runner.rb

@@ -0,0 +1,4 @@
+When /^I run the runner$/ do
+  @result = @runner.run
+end
+

data/features/support/env.rb

@@ -0,0 +1,7 @@
+require 'jasmine-headless-webkit'
+
+After do
+  FileUtils.rm_f 'spec/report.txt'
+  FileUtils.rm_f 'spec/runner.html'
+end
+

data/jasmine-headless-webkit-firstbanco.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jasmine/headless/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jasmine-headless-webkit-firstbanco"
+  s.version     = Jasmine::Headless::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John Bintz", "Sencha Inc.", "Pivotal Labs"]
+  s.email       = ["john@coswellproductions.com"]
+  s.homepage    = ""
+  s.summary     = %q{Run Jasmine specs headlessly in a WebKit browser.}
+  s.description = %q{Run Jasmine specs headlessly. This is a firstbanco gem fork of the originial project, as it appears to be dormant and we want to make our deploys easier.}
+
+  s.rubyforge_project = "jasmine-headless-webkit"
+
+  s.extensions    = `git ls-files -- ext/**/extconf.rb`.split("\n")
+  s.files         = `git ls-files`.split("\n") + Dir['jasmine/lib/*']
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'jasmine-core'
+  s.add_runtime_dependency 'coffee-script'
+  s.add_runtime_dependency 'rainbow'
+  s.add_runtime_dependency 'multi_json', '>= 1.2.0'
+  s.add_runtime_dependency 'sprockets'
+  s.add_runtime_dependency 'sprockets-vendor_gems'
+end
+

data/lib/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { 'jasmine' if File.file?('./.jasmine-headless-webkit') }

data/lib/autotest/jasmine.rb

@@ -0,0 +1,7 @@
+require 'autotest'
+require 'autotest/jasmine_mixin'
+
+class Autotest::Jasmine < Autotest
+  include JasmineMixin
+end
+

data/lib/autotest/jasmine_mixin.rb

@@ -0,0 +1,111 @@
+module JasmineMixin
+  JASMINE_PROGRAM = File.expand_path('../../../bin/jasmine-headless-webkit', __FILE__)
+
+  JAVASCRIPT_EXTENSIONS = %w{js coffee}
+
+  def self.included(klass)
+    klass::ALL_HOOKS << [ :run_jasmine, :ran_jasmine ]
+  end
+
+  attr_accessor :is_jasmine_running, :jasmine_to_run, :jasmine_ran_once
+
+  def initialize
+    super()
+    setup_jasmine_project_mappings
+    jasmine_ran_once = false
+  end
+
+  def get_to_green
+    begin
+      reset_jasmine(:no)
+      super if find_files_to_test
+
+      reset_jasmine(:yes)
+      self.last_mtime = Time.at(0) if !options[:no_full_after_start] && !jasmine_ran_once
+      run_jasmine if find_files_to_test
+
+      self.is_jasmine_running = :all
+      wait_for_changes unless all_jasmine_good
+    end until all_jasmine_good
+
+    reset_jasmine(:all)
+  end
+
+  def rerun_all_tests
+    reset_jasmine(:no)
+    super
+
+    reset_jasmine(:yes)
+    run_jasmine
+
+    reset_jasmine(:all)
+  end
+
+  def reset_jasmine(method)
+    self.files_to_test = new_hash_of_arrays
+    self.is_jasmine_running = method
+  end
+
+  def run_jasmine
+    hook :run_jasmine
+
+    self.jasmine_to_run = :all
+
+    if mtime = find_files_to_test
+      self.last_mtime = mtime
+    end
+
+    begin
+      system make_jasmine_cmd
+
+      self.jasmine_to_run = ($?.exitstatus == 0) ? :none : :all
+    end
+
+    hook :ran_jasmine
+
+    jasmine_ran_once = true
+  end
+
+  def all_jasmine_good
+    self.jasmine_to_run == :none
+    self.files_to_test = new_hash_of_arrays
+  end
+
+  def find_files
+    Hash[super.find_all { |file, mtime|
+      is_js = (file[%r{\.(#{JAVASCRIPT_EXTENSIONS.join('|')})$}] != nil)
+
+      case self.is_jasmine_running
+      when :all
+        true
+      when :no
+        !is_js
+      when :yes
+        is_js
+      end
+    }]
+  end
+
+  def make_jasmine_cmd
+    self.files_to_test.empty? ? '' :
+      %{#{JASMINE_PROGRAM} #{self.files_to_test.keys.collect { |key| %{'#{key}'} }.join(' ')}}.tap { |o| p o }
+  end
+
+  def setup_jasmine_project_mappings
+    add_mapping(%r{spec/javascripts/.*_spec\.(js|coffee)}) { |filename, _|
+      filename
+    }
+
+    add_mapping(%r{public/javascripts/(.*)\.js}) { |_, m|
+      files_matching(%r{spec/javascripts/#{m[1]}_spec\..*$})
+    }
+
+    add_mapping(%r{app/coffeescripts/(.*)\.coffee}) { |_, m|
+      files_matching(%r{spec/javascripts/#{m[1]}_spec\..*$})
+    }
+  end
+
+  def add_javascript_extensions(*extensions)
+    self.class::JAVASCRIPT_EXTENSIONS << extensions
+  end
+end

data/lib/autotest/jasmine_rspec2.rb

@@ -0,0 +1,7 @@
+require 'autotest/rspec2'
+require 'autotest/jasmine_mixin'
+
+class Autotest::JasmineRspec2 < Autotest::Rspec2
+  include JasmineMixin
+end
+

data/lib/jasmine-headless-webkit.rb

@@ -0,0 +1,3 @@
+require 'jasmine/headless'
+require 'jasmine/headless/railtie' if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+

data/lib/jasmine/headless.rb

@@ -0,0 +1,61 @@
+require 'pathname'
+
+module Jasmine
+  module Headless
+    
+    EXCLUDED_FORMATS = %w{less sass scss erb str}
+    
+    autoload :CommandLine, 'jasmine/headless/command_line'
+
+    autoload :CoffeeScriptCache, 'jasmine/headless/coffee_script_cache'
+    autoload :SpecFileAnalyzer, 'jasmine/headless/spec_file_analyzer'
+    autoload :CacheableAction, 'jasmine/headless/cacheable_action'
+    autoload :VERSION, 'jasmine/headless/version'
+    autoload :Runner, 'jasmine/headless/runner'
+    autoload :Options, 'jasmine/headless/options'
+    autoload :Task, 'jasmine/headless/task'
+
+    autoload :FilesList, 'jasmine/headless/files_list'
+    autoload :UniqueAssetList, 'jasmine/headless/unique_asset_list'
+
+    autoload :TemplateWriter, 'jasmine/headless/template_writer'
+    
+    autoload :FileChecker, 'jasmine/headless/file_checker'
+
+    autoload :CoffeeTemplate, 'jasmine/headless/coffee_template'
+    autoload :JSTemplate, 'jasmine/headless/js_template'
+    autoload :JSTTemplate, 'jasmine/headless/jst_template'
+    autoload :CSSTemplate, 'jasmine/headless/css_template'
+    autoload :NilTemplate, 'jasmine/headless/nil_template'
+
+    autoload :Report, 'jasmine/headless/report'
+    autoload :ReportMessage, 'jasmine/headless/report_message'
+
+    class << self
+      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
+
+require 'jasmine/headless/errors'
+

data/lib/jasmine/headless/cacheable_action.rb

@@ -0,0 +1,85 @@
+module Jasmine::Headless
+  class CacheableAction
+    class << self
+      def enabled=(bool)
+        @enabled = bool
+      end
+
+      def enabled?
+        @enabled = true if @enabled == nil
+        @enabled
+      end
+
+      def cache_type
+        raise ArgumentError.new("No cache type defined for #{self.name}") if @cache_type == nil
+        @cache_type
+      end
+
+      def cache_type=(type)
+        @cache_type = type
+      end
+
+      def cache_dir=(dir)
+        @cache_dir = dir
+      end
+
+      def cache_dir
+        @cache_dir ||= '.jhw-cache'
+      end
+
+      def for(file)
+        new(file).handle
+      end
+    end
+
+    attr_reader :file
+
+    def initialize(file)
+      @file = file
+    end
+
+    def handle
+      if CacheableAction.enabled?
+        if fresh?
+          unserialize(File.read(cache_file))
+        else
+          result = action
+          FileUtils.mkdir_p File.split(cache_file).first
+          File.open(cache_file, 'wb') { |fh| fh.print serialize(result) }
+          result
+        end
+      else
+        action
+      end
+    end
+
+    def cache_file
+      @cache_file ||= File.expand_path(relative_cache_file) + '.js'
+    end
+
+    def relative_cache_file
+      File.join(self.class.cache_dir, self.class.cache_type, file.gsub(Dir.pwd + '/', ''))
+    end
+
+    def fresh?
+      cached? && (File.mtime(file) < File.mtime(cache_file))
+    end
+
+    def cached?
+      File.exist?(cache_file)
+    end
+
+    def action
+      raise StandardError.new("Override action")
+    end
+
+    def serialize(data)
+      data
+    end
+
+    def unserialize(data)
+      data
+    end
+  end
+end
+