jasmine-headless-webkit 0.6.3 → 0.7.0

data/js-lib/jsDump.js

@@ -0,0 +1,209 @@
+/**
+ * jsDump
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 5/15/2008
+ * @projectDescription Advanced and extensible data dumping for Javascript.
+ * @version 1.0.0
+ * @author Ariel Flesler
+ * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
+ */
+var jsDump;
+
+(function(){
+	function quote( str ){
+		return '"' + str.toString().replace(/"/g, '\\"') + '"';
+	}
+	function literal( o ){
+		return o + '';
+	}
+	function join( pre, arr, post ){
+		var s = jsDump.separator(),
+			base = jsDump.indent(),
+			inner = jsDump.indent(1);
+		if( arr.join )
+			arr = arr.join( ',' + s + inner );
+		if( !arr )
+			return pre + post;
+		return [ pre, inner + arr, base + post ].join(s);
+	}
+	function array( arr ){
+		var i = arr.length, ret = Array(i);
+		this.up();
+		while( i-- )
+			ret[i] = this.parse( arr[i] );
+		this.down();
+		return join( '[', ret, ']' );
+	}
+	
+	var reName = /^function (\w+)/;
+	
+	jsDump = {
+    doParse:function(obj) {
+      this.alreadySeenObjects = [];
+      return this.parse(obj);
+    },
+		parse:function( obj, type ){//type is used mostly internally, you can fix a (custom)type in advance
+			var parser = this.parsers[ type || this.typeOf(obj) ];
+			type = typeof parser;
+			
+			return type == 'function' ? parser.call( this, obj ) :
+				type == 'string' ? parser :
+				this.parsers.error;
+		},
+		typeOf:function( obj ){
+			var type = typeof obj,
+				kind;
+
+			if ( type == 'object' || type == 'function' ) {
+				if ( obj === null )
+					return 'null';
+
+				// Extract Staff from [Object Staff]
+				kind = Object.prototype.toString.call(obj).slice(8, -1);
+				switch ( kind ) {
+					case 'Array':
+						return 'array';
+
+					case 'Date':
+						return 'date';
+
+					case 'RegExp':
+						return 'regexp';
+
+					case 'Window': //Firefox, IE, Opera
+					case 'DOMWindow': //WebKit
+					case 'global':
+						return 'window';
+
+					case 'HTMLDocument': //WebKit, Firefox, Opera
+					case 'Document': // IE
+						return 'document';
+
+					case 'NodeList':
+						return 'nodelist';
+
+					default:
+						if ( 'callee' in obj )
+							// Opera: Object.prototype.toString.call(arguments) == 'Object' :(
+							return 'arguments';
+						else if ( 'ownerDocument' in obj && 'defaultView' in obj.ownerDocument && obj instanceof obj.ownerDocument.defaultView.Node )
+							return 'node';
+				}
+			}
+			return type;
+		},
+		separator:function(){
+			return this.multiline ? this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';
+		},
+		indent:function( extra ){// extra can be a number, shortcut for increasing-calling-decreasing
+			if( !this.multiline )
+				return '';
+			var chr = this.indentChar;
+			if( this.HTML )
+				chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');
+			return Array( this._depth_ + (extra||0) ).join(chr);
+		},
+		up:function( a ){
+			this._depth_ += a || 1;
+		},
+		down:function( a ){
+			this._depth_ -= a || 1;
+		},
+		setParser:function( name, parser ){
+			this.parsers[name] = parser;
+		},
+		// The next 3 are exposed so you can use them
+		quote:quote, 
+		literal:literal,
+		join:join,
+		_depth_: 1,
+		// This is the list of parsers, to modify them, use jsDump.setParser
+		parsers:{
+			window: '[Window]',
+			document: '[Document]',
+			error:'[ERROR]', //when no parser is found, shouldn't happen
+			unknown: '[Unknown]',
+			'null':'null',
+			undefined:'undefined',
+			'function':function( fn ){
+				var ret = 'function',
+					name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
+				if( name )
+					ret += ' ' + name;
+				ret += '(';
+				ret = [ ret, this.parse( fn, 'functionArgs' ), '){'].join('');
+				return join( ret, this.parse(fn,'functionCode'), '}' );
+			},
+			array: array,
+			nodelist: array,
+			arguments: array,
+			object:function( map ){
+				var ret = [ ];
+				this.up();
+        var keys = [];
+        for (var key in map) { keys.push(key); }
+        keys = keys.sort();
+
+        for( var i = 0; i < keys.length; ++i ) {
+          var key = keys[i];
+          if (!this.ignoreFunctions || this.typeOf(map[key]) != 'function') {
+            var value = "<< LOOP >>";
+
+            if ((typeof map[key] != 'object') || this.alreadySeenObjects.indexOf(map[key]) == -1) {
+              this.alreadySeenObjects.push(map[key]);
+              value = this.parse(map[key]);
+            }
+
+            ret.push( this.parse(key,'key') + ': ' + value );
+          }
+        }
+				this.down();
+				return join( '{', ret, '}' );
+			},
+			node:function( node ){
+				var open = this.HTML ? '&lt;' : '<',
+					close = this.HTML ? '&gt;' : '>';
+				var tag = node.nodeName.toLowerCase(),
+					ret = open + tag;
+				for( var a in this.DOMAttrs ){
+					var val = node[this.DOMAttrs[a]];
+					if( val )
+						ret += ' ' + a + '=' + this.parse( val, 'attribute' );
+				}
+				return ret + close + open + '/' + tag + close;
+			},
+			functionArgs:function( fn ){//function calls it internally, it's the arguments part of the function
+				var l = fn.length;
+				if( !l ) return '';
+				var args = Array(l);
+				while( l-- )
+					args[l] = String.fromCharCode(97+l);//97 is 'a'
+				return ' ' + args.join(', ') + ' ';
+			},
+			key:quote, //object calls it internally, the key part of an item in a map
+			functionCode:'[code]', //function calls it internally, it's the content of the function
+			attribute:quote, //node calls it internally, it's an html attribute value
+			string:quote,
+			date:quote,
+			regexp:literal, //regex
+			number:literal,
+			'boolean':literal
+		},
+		DOMAttrs:{//attributes to dump from nodes, name=>realName
+			id:'id',
+			name:'name',
+			'class':'className'
+		},
+    alreadySeenObjects:[],
+    ignoreFunctions:true,
+		HTML:false,//if true, entities are escaped ( <, >, \t, space and \n )
+		indentChar:'  ',//indentation unit
+		multiline:true //if true, items in a collection, are separated by a \n, else just a space.
+	};
+
+})();
+
+if (typeof exports !== 'undefined') {
+	module.exports = jsDump;
+}

data/lib/jasmine/files_list.rb

@@ -1,31 +1,20 @@
 require 'jasmine-core'
 require 'iconv'
+require 'time'
 
 module Jasmine
   class FilesList
-    attr_reader :files, :filtered_files, :spec_outside_scope
+    attr_reader :files, :spec_files, :filtered_files, :spec_outside_scope
 
     DEFAULT_FILES = [
       File.join(Jasmine::Core.path, "jasmine.js"),
       File.join(Jasmine::Core.path, "jasmine-html.js"),
-      File.expand_path('../../../jasmine/jasmine.headless-reporter.js', __FILE__)
+      File.expand_path('../../../jasmine/jasmine.headless-reporter.js', __FILE__),
+      File.expand_path('../../../js-lib/jsDump.js', __FILE__),
+      File.expand_path('../../../js-lib/beautify-html.js', __FILE__)
     ]
 
-    class << self
-      def get_spec_line_numbers(file)
-        line_numbers = {}
-
-        ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
-        file.lines.each_with_index.each { |line, index|
-          line = ic.iconv(line + ' ')[0..-2]
-          if description = line[%r{(describe|context|it)[( ]*(["'])(.*)\2}, 3]
-            (line_numbers[description] ||= []) << (index + 1)
-          end
-        }
-
-        line_numbers
-      end
-    end
+    PLEASE_WAIT_IM_WORKING_TIME = 2
 
     def initialize(options = {})
       @options = options
@@ -55,7 +44,7 @@ module Jasmine
     def spec_file_line_numbers
       @spec_file_line_numbers ||= Hash[@spec_files.collect { |file|
         if File.exist?(file)
-          if !(lines = self.class.get_spec_line_numbers(File.read(file))).empty?
+          if !(lines = Jasmine::Headless::SpecFileAnalyzer.for(file)).empty?
             [ file, lines ]
           end
         else
@@ -66,51 +55,31 @@ module Jasmine
 
     private
     def to_html(files)
-      coffeescript_run = []
+      alert_time = Time.now + PLEASE_WAIT_IM_WORKING_TIME
 
       files.collect { |file|
-        coffeescript_run << file if (ext = File.extname(file)) == '.coffee'
-          
-        output = []
-        if (files.last == file or ext != '.coffee') and !coffeescript_run.empty?
-          output << ensure_coffeescript_run!(coffeescript_run)
+        if alert_time && alert_time < Time.now
+          puts "Rebuilding cache, please wait..."
+          alert_time = nil
         end
 
-        if ext != '.coffee'
-          output << case File.extname(file)
-          when '.js'
-            %{<script type="text/javascript" src="#{file}"></script>}
-          when '.css'
-            %{<link rel="stylesheet" href="#{file}" type="text/css" />}
+        case File.extname(file)
+        when '.coffee'
+          begin
+            %{<script type="text/javascript">#{Jasmine::Headless::CoffeeScriptCache.for(file)}</script>}
+          rescue CoffeeScript::CompilationError => ne
+            puts "[%s] %s: %s" % [ 'coffeescript'.color(:red), file.color(:yellow), ne.message.to_s.color(:white) ]
+            raise ne
+          rescue StandardError => e
+            puts "[%s] Error in compiling one of the followng: %s" % [ 'coffeescript'.color(:red), files.join(' ').color(:yellow) ]
+            raise e
           end
+        when '.js'
+          %{<script type="text/javascript" src="#{file}"></script>}
+        when '.css'
+          %{<link rel="stylesheet" href="#{file}" type="text/css" />}
         end
-
-        output
-      }.flatten.reject(&:empty?)
-    end
-
-    def ensure_coffeescript_run!(files)
-      data = StringIO.new
-      files.each { |file| data << File.read(file) << "\n" }
-      data.rewind
-
-      %{<script type="text/javascript">#{CoffeeScript.compile(data)}</script>}
-    rescue CoffeeScript::CompilationError => e
-      files.each do |file|
-        begin
-          CoffeeScript.compile(fh = File.open(file))
-        rescue CoffeeScript::CompilationError => ne
-          puts "[%s] %s: %s" % [ 'coffeescript'.color(:red), file.color(:yellow), ne.message.to_s.color(:white) ]
-          raise ne
-        ensure
-          fh.close
-        end
-      end
-    rescue StandardError => e
-      puts "[%s] Error in compiling one of the followng: %s" % [ 'coffeescript'.color(:red), files.join(' ').color(:yellow) ]
-      raise e
-    ensure
-      files.clear
+      }.flatten.compact.reject(&:empty?)
     end
 
     def spec_filter
@@ -131,15 +100,17 @@ module Jasmine
             @files += found_files
 
             if searches == 'spec_files'
-              @spec_files = @files + spec_filter
+              @spec_files += spec_filter.empty? ? found_files : (found_files & spec_filter)
             end
 
-            @filtered_files += (if searches == 'spec_files'
-              @spec_outside_scope = ((spec_filter | found_files).sort != found_files.sort)
-              spec_filter.empty? ? found_files : (spec_filter || found_files)
-            else
-              found_files
-            end)
+            @filtered_files +=  begin
+                                  if searches == 'spec_files'
+                                    @spec_outside_scope = ((spec_filter | found_files).sort != found_files.sort)
+                                    spec_filter.empty? ? found_files : (spec_filter || found_files)
+                                  else
+                                    found_files
+                                  end
+                                end
           end
         end
       end

data/lib/jasmine/headless/cacheable_action.rb

@@ -0,0 +1,77 @@
+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.join(self.class.cache_dir, self.class.cache_type, Digest::SHA1.hexdigest(file))
+    end
+
+    def fresh?
+      File.exist?(cache_file) && (File.mtime(file) < File.mtime(cache_file))
+    end
+
+    def action
+      raise StandardError.new("Override action")
+    end
+
+    def serialize(data)
+      data
+    end
+
+    def unserialize(data)
+      data
+    end
+  end
+end
+

data/lib/jasmine/headless/coffee_script_cache.rb

@@ -0,0 +1,20 @@
+require 'coffee_script'
+require 'digest/sha1'
+require 'fileutils'
+
+module Jasmine
+  module Headless
+    class CoffeeScriptCache < CacheableAction
+      class << self
+        def cache_type
+          "coffee_script"
+        end
+      end
+
+      def action
+        CoffeeScript.compile(File.read(file))
+      end
+    end
+  end
+end
+

data/lib/jasmine/headless/errors.rb

@@ -10,6 +10,7 @@ module Jasmine
     class ConsoleLogUsage < StandardError ; end
 
     class JasmineConfigNotFound < Errno::ENOENT ; end
+    class InvalidReport < StandardError ; end
   end
 end
 

data/lib/jasmine/headless/options.rb

@@ -13,11 +13,13 @@ module Jasmine
         :remove_html_file => true,
         :jasmine_config => 'spec/javascripts/support/jasmine.yml',
         :report => false,
+        :do_list => false,
         :full_run => true,
+        :enable_cache => true,
         :files => []
       }
 
-      DEFAULTS_FILE = '.jasmine-headless-webkit'
+      DEFAULTS_FILE = File.join(Dir.pwd, '.jasmine-headless-webkit')
       GLOBAL_DEFAULTS_FILE = File.expand_path("~/#{DEFAULTS_FILE}")
 
       def self.from_command_line
@@ -29,6 +31,7 @@ module Jasmine
 
       def initialize(opts = {})
         @options = DEFAULT_OPTIONS.dup
+        read_defaults_files
         opts.each { |k, v| @options[k] = v if v }
       end
 
@@ -40,6 +43,10 @@ module Jasmine
           @options[:colors] = true
         when '--no-colors', '-nc'
           @options[:colors] = false
+        when '--cache'
+          @options[:enable_cache] = true
+        when '--no-cache'
+          @options[:enable_cache] = false
         when '--keep'
           @options[:remove_html_file] = false
         when '--report'
@@ -48,6 +55,8 @@ module Jasmine
           @options[:jasmine_config] = arg
         when '--no-full-run'
           @options[:full_run] = false
+        when '--list', '-l'
+          @options[:do_list] = true
         end
       end
 
@@ -63,10 +72,13 @@ module Jasmine
         command_line_args = GetoptLong.new(
           [ '--colors', '-c', GetoptLong::NO_ARGUMENT ],
           [ '--no-colors', GetoptLong::NO_ARGUMENT ],
+          [ '--cache', GetoptLong::NO_ARGUMENT ],
+          [ '--no-t stcache', GetoptLong::NO_ARGUMENT ],
           [ '--keep', GetoptLong::NO_ARGUMENT ],
           [ '--report', GetoptLong::REQUIRED_ARGUMENT ],
           [ '--jasmine-config', '-j', GetoptLong::REQUIRED_ARGUMENT ],
-          [ '--no-full-run', GetoptLong::NO_ARGUMENT ]
+          [ '--no-full-run', GetoptLong::NO_ARGUMENT ],
+          [ '--list', '-l', GetoptLong::NO_ARGUMENT ]
         )
 
         command_line_args.each { |*args| process_option(*args) }

data/lib/jasmine/headless/railtie.rb

@@ -1,5 +1,3 @@
-require 'jasmine/headless/task'
-
 module Jasmine
   module Headless
     class Railtie < Rails::Railtie

data/lib/jasmine/headless/report.rb

@@ -0,0 +1,76 @@
+require 'forwardable'
+
+module Jasmine::Headless
+  class Report
+    extend Forwardable
+
+    def_delegators :report, :length, :[]
+    def_delegators :last_total, :total, :failed, :time
+
+    class << self
+      def load(file)
+        new(file).process
+      end
+    end
+
+    attr_reader :file, :report
+
+    def initialize(file)
+      @file = file
+    end
+
+    def process
+      last_message = nil
+      @report = File.readlines(file).collect do |line|
+        type, *parts = line.split('||', -1)
+
+        if !(report_klass = report_class_for(type))
+          if last_message.kind_of?(Jasmine::Headless::ReportMessage::Console)
+            last_message.message << "\n"
+            last_message.message << line.strip
+          end
+        else
+          parts.last.strip!
+
+          last_message = report_klass.new_from_parts(parts)
+        end
+      end
+      self
+    end
+
+    def has_used_console?
+      @report.any? { |entry| entry.kind_of?(Jasmine::Headless::ReportMessage::Console) }
+    end
+
+    def has_failed_on?(statement)
+      @report.any? { |entry| 
+        if entry.kind_of?(Jasmine::Headless::ReportMessage::Fail)
+          entry.statement == statement
+        end
+      }
+    end
+
+    def valid?
+      last_total != nil
+    end
+
+    def failed_files
+      @report.find_all { |entry| 
+        entry.kind_of?(Jasmine::Headless::ReportMessage::Fail)
+      }.collect(&:filename).uniq.compact
+    end
+
+    private
+
+    def last_total
+      @report.reverse.find { |entry| entry.respond_to?(:total) }
+    end
+
+    def report_class_for(type)
+      if constant = ReportMessage.constants.find { |k| k.to_s.downcase == type.downcase }
+        ReportMessage.const_get(constant)
+      end
+    end
+  end
+end
+

data/lib/jasmine/headless/report_message/console.rb

@@ -0,0 +1,20 @@
+module Jasmine::Headless::ReportMessage
+  class Console
+    class << self
+      def new_from_parts(parts)
+        new(parts.first)
+      end
+    end
+
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+
+    def ==(other)
+      self.message == other.message
+    end
+  end
+end
+

data/lib/jasmine/headless/report_message/error.rb

@@ -0,0 +1,20 @@
+module Jasmine::Headless::ReportMessage
+  class Error
+    class << self
+      def new_from_parts(parts)
+        new(*parts)
+      end
+    end
+
+    attr_reader :message, :file_info
+
+    def initialize(message, file_info)
+      @message, @file_info = message, file_info
+    end
+
+    def ==(other)
+      self.message == other.message && self.file_info == other.file_info
+    end
+  end
+end
+

data/lib/jasmine/headless/report_message/fail.rb

@@ -0,0 +1,5 @@
+module Jasmine::Headless::ReportMessage
+  class Fail < Spec
+  end
+end
+

data/lib/jasmine/headless/report_message/pass.rb

@@ -0,0 +1,5 @@
+module Jasmine::Headless::ReportMessage
+  class Pass < Spec
+  end
+end
+

data/lib/jasmine/headless/report_message/spec.rb

@@ -0,0 +1,30 @@
+module Jasmine::Headless::ReportMessage
+  class Spec
+    class << self
+      def new_from_parts(parts)
+        file_info = parts.pop
+
+        new(parts.join(' '), file_info)
+      end
+    end
+
+    attr_reader :statement, :file_info
+
+    def initialize(statement, file_info)
+      @statement, @file_info = statement, file_info
+    end
+
+    def ==(other)
+      self.statement == other.statement && self.file_info == other.file_info
+    end
+
+    def filename
+      if name = file_info.split(":").first
+        name
+      else
+        nil
+      end
+    end
+  end
+end
+