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

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

@@ -0,0 +1,31 @@
+module Jasmine::Headless::ReportMessage
+  class Total
+    class << self
+      def new_from_parts(parts)
+        new(*parts)
+      end
+    end
+
+    attr_reader :total, :failed, :time, :has_js_error
+
+    def initialize(total, failed, time, has_js_error)
+      @total, @failed, @time = total.to_i, failed.to_i, time.to_f
+
+      @has_js_error = case has_js_error
+      when String
+        has_js_error == "T"
+      else
+        has_js_error
+      end
+    end
+
+    def ==(other)
+      other &&
+      self.total == other.total &&
+      self.failed == other.failed &&
+      self.time == other.time &&
+      self.has_js_error == other.has_js_error
+    end
+  end
+end
+

data/lib/jasmine/headless/runner.rb

@@ -0,0 +1,264 @@
+require 'fileutils'
+
+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' ],
+        'helpers' => [ 'helpers/**/*.js' ],
+        'spec_dir' => 'spec/javascripts',
+        'src_dir' => nil,
+        'stylesheets' => [],
+        'src_files' => [],
+        'backtrace' => []
+      }
+
+      RUNNER_DIR = File.expand_path('../../../../ext/jasmine-webkit-specrunner', __FILE__)
+      RUNNER = File.join(RUNNER_DIR, 'jasmine-webkit-specrunner')
+
+      attr_reader :options
+
+      def self.run(options = {})
+        new(options).run
+      end
+
+      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
+
+          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
+
+      def template_writer
+        @template_writer ||= TemplateWriter.new(self)
+      end
+
+      def jasmine_config
+        return @jasmine_config if @jasmine_config
+
+        @jasmine_config = JASMINE_DEFAULTS.dup
+        jasmine_config_data.each do |key, value|
+          @jasmine_config[key] = value if value
+        end
+        @jasmine_config
+      end
+
+      def computed_jasmine_command
+        Jasmine::Headless::CacheableAction.enabled = @options[:enable_cache]
+        Jasmine::Headless.show_warnings = !@options[:quiet]
+        FilesList.reset!
+
+        self.class.server_port = options[:server_port]
+
+        @_targets = template_writer.write
+
+        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?
+            run_targets.pop
+          end
+        end
+        jasmine_command(run_targets)
+      end
+
+      def jasmine_command(*targets)
+        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
+        runner = lambda { system computed_jasmine_command }
+
+        if options[:use_server]
+          wrap_in_server(run_targets, &runner)
+        else
+          runner.call
+        end
+
+        @_status = $?.exitstatus
+      ensure
+        if @_targets && !runner_filename && (@options[:remove_html_file] || (@_status == 0))
+          @_targets.each { |target| FileUtils.rm_f target }
+        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?
+            runner_output
+          else
+            false
+          end
+        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(ERB.new(File.read(@options[:jasmine_config])).result(binding))
+      end
+    end
+  end
+end
+

data/lib/jasmine/headless/spec_file_analyzer.rb

@@ -0,0 +1,44 @@
+require 'multi_json'
+
+module Jasmine::Headless
+  class SpecFileAnalyzer < CacheableAction
+    class << self
+      def cache_type
+        "spec_file_analysis"
+      end
+    end
+
+    def action
+      line_numbers = {}
+
+      data = File.read(file)
+
+      if data.respond_to?(:encode)
+        data.encode!('US-ASCII', 'UTF-8', :invalid => :replace, :undef => :replace)
+      else
+        require 'iconv'
+        ic = Iconv.new('UTF-8//IGNORE', 'US-ASCII')
+        data = ic.iconv(File.read(file) + ' ')[0..-2]
+      end
+
+      data.force_encoding('US-ASCII') if data.respond_to?(:force_encoding)
+
+      data.lines.each_with_index.each { |line, index|
+        if description = line[%r{(describe|context|it)[( ]*(["'])(.*)\2}, 3]
+          (line_numbers[description] ||= []) << (index + 1)
+        end
+      }
+
+      line_numbers
+    end
+
+    def serialize(data)
+      MultiJson.dump(data)
+    end
+
+    def unserialize(data)
+      MultiJson.load(data)
+    end
+  end
+end
+

data/lib/jasmine/headless/task.rb

@@ -0,0 +1,39 @@
+module Jasmine
+  module Headless
+    class Task
+      include Rake::DSL if defined?(Rake::DSL)
+
+      attr_accessor :colors, :keep_on_error, :jasmine_config, :error_on_console_log
+
+      def initialize(name = 'jasmine:headless')
+        @colors = false
+        @keep_on_error = false
+        @error_on_console_log = true
+        @jasmine_config = nil
+
+        yield self if block_given?
+
+        desc 'Run Jasmine specs headlessly'
+        task(name) { run_rake_task }
+      end
+
+      private
+      def run_rake_task
+        result = Jasmine::Headless::Runner.run(
+                    :colors => colors,
+                    :remove_html_file => !@keep_on_error,
+                    :jasmine_config => @jasmine_config
+                )
+        case result
+          when 1
+            raise Jasmine::Headless::TestFailure
+          when 2
+            raise Jasmine::Headless::ConsoleLogUsage if @error_on_console_log
+          else
+            p "Unexpected Jasmine::Headless error code #{result}. If 127, check native extensions have been compiled."
+            raise Jasmine::Headless::TestFailure
+        end
+      end
+    end
+  end
+end

data/lib/jasmine/headless/template_writer.rb

@@ -0,0 +1,65 @@
+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
+      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.each do |name, files|
+        template = template_for(files)
+
+        File.open(name, 'wb') { |fh| fh.print template }
+      end
+
+      output.collect(&:first)
+    end
+
+    def all_tests_filename
+      runner.runner_filename || "jhw.#{$$}.html"
+    end
+
+    def filtered_tests_filename
+      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 = files_list.spec_file_line_numbers
+
+      ERB.new(Jasmine::Headless.root.join('skel/template.html.erb').read).result(binding)
+    end
+  end
+end
+

data/lib/jasmine/headless/unique_asset_list.rb

@@ -0,0 +1,16 @@
+module Jasmine::Headless
+  class UniqueAssetList < ::Array
+    def <<(asset)
+      raise InvalidUniqueAsset.new("Not an asset: #{asset.inspect}") if !asset.respond_to?(:logical_path)
+
+      super if !self.any? { |other| asset.pathname == other.pathname }
+    end
+
+    def flatten
+      self.collect(&:to_a).flatten
+    end
+  end
+
+  class InvalidUniqueAsset < StandardError ; end
+end
+