gaffo-jasmine_webos 0.0.1

data/lib/jasminewebos/cli.rb

@@ -0,0 +1,57 @@
+require 'optparse'
+require 'fileutils'
+
+module Jasminewebos
+  class CLI
+    def self.execute(stdout, arguments=[])
+      command = ""
+      mandatory_options = %w(  )
+      
+      generate = false
+      start_server = false
+      
+      parser = OptionParser.new do |opts|
+        opts.banner = <<-BANNER.gsub(/^          /,'')
+          Tools for working with jasmine_webos
+
+          Usage: 
+          #{File.basename($0)} -g
+          generates the jasmine files in the current directory
+          
+          #{File.basename($0)} -s
+          starts the jasmine server from the current directory
+          
+          Options:
+        BANNER
+        opts.separator ""
+        opts.on("-g", String,
+                "Starts the jasmine server from the current directory") { generate = true }
+        opts.on("-s", String,
+                "Generate the jasmine files in the current directory") { start_server = true }
+        opts.on("-h", "--help",
+                "Show this help message.") { stdout.puts opts; exit }
+        opts.parse!(arguments)
+        
+        if mandatory_options && mandatory_options.find { |option| options[option.to_sym].nil? }
+          stdout.puts opts; exit
+        end
+      end
+      
+      config = Jasminewebos::Configuration.new(FileUtils.pwd)
+      
+      self.generate_stub(config) if generate
+      self.launch_server(config) if start_server
+      
+    end
+    
+    def self.generate_stub(config)
+      puts("Generating jasmine_webos required files")
+      Jasminewebos::Generator.new(config).run
+      puts("  Complete.")
+    end
+    
+    def self.launch_server(config)
+      Jasminewebos::Server.new(config).start
+    end
+  end
+end

data/lib/jasminewebos/configuration.rb

@@ -0,0 +1,16 @@
+module Jasminewebos
+  class Configuration
+    attr_accessor :port, :jasmine_root, :application_root, :specs_dir,
+                  :matchers_dir, :sources_json, :jasminewebos_root
+    
+    def initialize(application_root)
+      @port = 8888
+      @jasminewebos_root = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+      @jasmine_root = File.join(@jasminewebos_root, "vendor", "jasmine")
+      @application_root = application_root
+      @specs_dir = File.join(@application_root, "spec", "javascript", "spec")
+      @matchers_dir = File.join(@application_root, "spec", "javascript", "matchers")
+      @sources_json = File.join(@application_root, "sources.json")
+    end
+  end    
+end

data/lib/jasminewebos/generator.rb

@@ -0,0 +1,13 @@
+require 'fileutils'
+module Jasminewebos
+  class Generator
+    def initialize(config)
+      @config = config
+    end
+    def run
+      from = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "templates", "webos", "spec"))
+      FileUtils.cp_r(from,
+                     @config.application_root)
+    end
+  end
+end

data/lib/jasminewebos/server.rb

@@ -0,0 +1,68 @@
+module Jasminewebos
+  class Server
+    def initialize(configuration)
+      @configuration = configuration
+    end
+    
+    def start
+      puts "Starting JasmineWebOS Server from #{@configuration.application_root}"
+      
+      require File.expand_path(File.join(@configuration.jasmine_root, 
+                                         "contrib", 
+                                         "ruby", 
+                                         "jasmine_spec_builder"))
+                                         
+      
+      puts source_files
+      Jasmine::SimpleServer.start(@configuration.port,
+                                  lambda{spec_files},
+                                  dir_mappings,
+                                  lambda{source_files})
+    end
+    
+    def spec_files
+      raw_specs = Dir.glob(File.join(@configuration.specs_dir, "**/*[Ss]pec.js"))
+      raw_specs.collect {|f| f.sub(@configuration.specs_dir, "/spec")}
+    end
+    
+    def source_files
+      jasmine = Dir.glob(File.join(jasmine_lib_dir, "*"))
+      jasmine = jasmine.collect {|f| f.sub(jasmine_lib_dir, "/lib")}
+      
+      matchers = Dir.glob(File.join(@configuration.matchers_dir, "**/*.js"))
+      matchers = matchers.collect {|f| f.sub(@configuration.matchers_dir, "/matchers")}
+      
+      sources = Dir.glob(File.join(application_src_dir, "**/*.js"))
+      sources = sources.collect {|f| f.sub(application_src_dir, "/app")}
+      
+      framework = Dir.glob(File.join(framework_dir, "**/*.js"))
+      framework = framework.collect {|f| f.sub(framework_dir, "/framework")}
+      
+      framework + jasmine.sort.reverse + matchers.sort + sources.sort
+    end
+    
+    def dir_mappings
+      {
+              "/framework" => framework_dir,
+              "/app" => application_src_dir,
+              "/spec" => @configuration.specs_dir,
+              "/matchers" => @configuration.matchers_dir,
+              "/lib" => jasmine_lib_dir,
+              "/matchers" => @configuration.matchers_dir
+      }
+    end
+    
+    private
+    def framework_dir
+      File.join(@configuration.jasminewebos_root, "jslib")
+    end
+    
+    def application_src_dir
+      File.join(@configuration.application_root, "app")
+    end
+    
+    def jasmine_lib_dir
+      File.expand_path(File.join(@configuration.jasmine_root, "lib"))
+    end
+  end
+end

data/lib/jasminewebos.rb

@@ -0,0 +1,20 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Jasminewebos
+  VERSION = '0.0.1'
+  
+#  def configure(&block)
+#    @@configuration = Jasminewebos::Configuration.new
+#    yield @@configuration
+#  end
+#  
+#  def configuration
+#    @@configuration
+#  end
+end
+
+require "jasminewebos/cli"
+require "jasminewebos/server"
+require "jasminewebos/generator"
+require "jasminewebos/configuration"

data/templates/webos/spec/javascript/matchers/all_matchers.js

@@ -0,0 +1,12 @@
+/**
+ * This file contains matchers that are for all tests
+ */
+/**
+ * Matcher that expects to be undefined
+ */
+jasmine.Matchers.prototype.toBeUndefined = function() {
+  return this.report((this.actual === undefined),
+    'Expected a value to be undefined but it was defined (' + this.report + ').');
+};
+/** @deprecated */
+jasmine.Matchers.prototype.should_be_defined = jasmine.Matchers.prototype.toBeDefined;

data/templates/webos/spec/javascript/spec/sample_spec.js

@@ -0,0 +1,5 @@
+describe("sample", function(){
+    it("should allow true to be true", function(){
+        expect(true).toEqual(true);
+    });
+});

data/test/jasminewebos/test_configuration.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class Jasminewebos::TestConfiguration < Test::Unit::TestCase
+  
+  context "with a default config" do
+    setup do
+      @config = Jasminewebos::Configuration.new(File.dirname(__FILE__))
+    end
+    should "have default port" do
+      assert_equal(8888, @config.port)
+    end
+    should "have jasmine_root" do
+      assert_equal(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "vendor", "jasmine")),
+                   @config.jasmine_root)
+    end
+    should "have an app root" do
+      assert_equal(File.dirname(__FILE__), @config.application_root)
+    end
+    
+    should "have sources.json" do
+      assert_equal(File.join(File.dirname(__FILE__), "sources.json"), @config.sources_json)
+    end
+    
+    should "have specs_dir" do 
+      assert_equal(File.join(File.dirname(__FILE__), "spec", "javascript", "spec"), @config.specs_dir)
+    end
+    
+    should "have matchers_dir" do
+      assert_equal(File.join(File.dirname(__FILE__), "spec", "javascript", "matchers"), @config.matchers_dir)
+    end
+    
+    should "have jasminewebos_root" do
+      assert_equal(File.expand_path(File.join(File.dirname(__FILE__), "..", "..")),
+                   @config.jasminewebos_root)
+    end
+  end
+  
+end

data/test/jasminewebos/test_jasminewebos_cli.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "/../test_helper.rb")
+require 'jasminewebos/cli'
+
+class TestJasminewebosCli < Test::Unit::TestCase
+#  def setup
+#    Jasminewebos::CLI.execute(@stdout_io = StringIO.new, [])
+#    @stdout_io.rewind
+#    @stdout = @stdout_io.read
+#  end
+#  
+#  def test_print_default_output
+#    assert_match(/To update this executable/, @stdout)
+#  end
+
+  def test_true
+    
+  end
+end

data/test/jasminewebos/test_server.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class Jasminewebos::TestServer < Test::Unit::TestCase
+  def test_monkeys
+    
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'stringio'
+require 'test/unit'
+require 'shoulda'
+require File.dirname(__FILE__) + '/../lib/jasminewebos'

data/test/test_jasminewebos.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestJasminewebos < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/vendor/jasmine/contrib/ruby/jasmine_runner.rb

@@ -0,0 +1,249 @@
+require 'socket'
+require 'erb'
+require 'json'
+
+module Jasmine
+  def self.root
+    File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+  end
+
+  # this seemingly-over-complex method is necessary to get an open port on at least some of our Macs
+  def self.open_socket_on_unused_port
+    infos = Socket::getaddrinfo("localhost", nil, Socket::AF_UNSPEC, Socket::SOCK_STREAM, 0, Socket::AI_PASSIVE)
+    families = Hash[*infos.collect { |af, *_| af }.uniq.zip([]).flatten]
+
+    return TCPServer.open('0.0.0.0', 0) if families.has_key?('AF_INET')
+    return TCPServer.open('::', 0) if families.has_key?('AF_INET6')
+    return TCPServer.open(0)
+  end
+
+  def self.find_unused_port
+    socket = open_socket_on_unused_port
+    port = socket.addr[1]
+    socket.close
+    port
+  end
+
+  def self.server_is_listening_on(hostname, port)
+    require 'socket'
+    begin
+      socket = TCPSocket.open(hostname, port)
+    rescue Errno::ECONNREFUSED
+      return false
+    end
+    socket.close
+    true
+  end
+
+  def self.wait_for_listener(port, name = "required process", seconds_to_wait = 10)
+    time_out_at = Time.now + seconds_to_wait
+    until server_is_listening_on "localhost", port
+      sleep 0.1
+      puts "Waiting for #{name} on #{port}..."
+      raise "#{name} didn't show up on port #{port} after #{seconds_to_wait} seconds." if Time.now > time_out_at
+    end
+  end
+
+  def self.kill_process_group(process_group_id, signal="TERM")
+    Process.kill signal, -process_group_id # negative pid means kill process group. (see man 2 kill)
+  end
+
+  def self.cachebust(files, root_dir="", replace=nil, replace_with=nil)
+    files.collect do |file_name|
+      real_file_name = replace && replace_with ? file_name.sub(replace, replace_with) : file_name
+      begin
+        digest = Digest::MD5.hexdigest(File.read("#{root_dir}#{real_file_name}"))
+      rescue
+        digest = "MISSING-FILE"
+      end
+      "#{file_name}?cachebust=#{digest}"
+    end
+  end
+
+  class RunAdapter
+    def initialize(spec_files_or_proc, jasmine_files = nil)
+      @spec_files_or_proc = spec_files_or_proc
+      @jasmine_files = jasmine_files || [
+        "/__JASMINE_ROOT__/lib/" + File.basename(Dir.glob("#{Jasmine.root}/lib/jasmine*.js").first),
+        "/__JASMINE_ROOT__/lib/TrivialReporter.js",
+        "/__JASMINE_ROOT__/lib/json2.js"
+      ]
+    end
+
+    def call(env)
+      spec_files = @spec_files_or_proc
+      spec_files = spec_files.call if spec_files.respond_to?(:call)
+
+      jasmine_files = @jasmine_files
+      jasmine_files = jasmine_files.call if jasmine_files.respond_to?(:call)
+
+      css_files = ["/__JASMINE_ROOT__/lib/jasmine.css"]
+
+      body = ERB.new(File.read(File.join(File.dirname(__FILE__), "run.html"))).result(binding)
+      [
+        200,
+        { 'Content-Type' => 'text/html' },
+        body
+      ]
+    end
+  end
+
+  class Redirect
+    def initialize(url)
+      @url = url
+    end
+
+    def call(env)
+      [
+        302,
+        { 'Location' => @url },
+        []
+      ]
+    end
+  end
+
+  class JsAlert
+    def call(env)
+      [
+        200,
+        { 'Content-Type' => 'application/javascript' },
+        "document.write('<p>Couldn\\'t load #{env["PATH_INFO"]}!</p>');"
+      ]
+    end
+  end
+
+  class SimpleServer
+    def self.start(port, spec_files_or_proc, mappings, jasmine_files = nil)
+      require 'thin'
+
+      config = {
+        '/run.html' => Jasmine::Redirect.new('/'),
+        '/' => Jasmine::RunAdapter.new(spec_files_or_proc, jasmine_files)
+      }
+      mappings.each do |from, to|
+        config[from] = Rack::File.new(to)
+      end
+
+      config["/__JASMINE_ROOT__"] = Rack::File.new(Jasmine.root)
+
+      app = Rack::Cascade.new([
+        Rack::URLMap.new(config),
+        JsAlert.new
+      ])
+
+      Thin::Server.start('0.0.0.0', port, app)
+    end
+  end
+
+  class SimpleClient
+    def initialize(selenium_host, selenium_port, selenium_browser_start_command, http_address)
+      require 'selenium/client'
+      @driver = Selenium::Client::Driver.new(
+        selenium_host,
+        selenium_port,
+        selenium_browser_start_command,
+        http_address
+      )
+      @http_address = http_address
+    end
+
+    def tests_have_finished?
+      @driver.get_eval("window.jasmine.getEnv().currentRunner.finished") == "true"
+    end
+
+    def connect
+      @driver.start
+      @driver.open("/")
+    end
+
+    def disconnect
+      @driver.stop
+    end
+
+    def run
+      until tests_have_finished? do
+        sleep 0.1
+      end
+
+      puts @driver.get_eval("window.getResults()")
+      failed_count = @driver.get_eval("window.jasmine.getEnv().currentRunner.getResults().failedCount").to_i
+      failed_count == 0
+    end
+
+    def eval_js(script)
+      escaped_script = "'" + script.gsub(/(['\\])/) { '\\' + $1 } + "'"
+
+      begin
+        result = @driver.get_eval("window.eval(#{escaped_script})")
+      rescue Selenium::CommandError
+        result = @driver.get_eval("eval(#{escaped_script}, window)")
+      end
+      JSON.parse("[#{result}]")[0]
+    end
+  end
+
+  class Runner
+    def initialize(selenium_jar_path, spec_files, dir_mappings, jasmine_files = nil)
+      @selenium_jar_path = selenium_jar_path
+      @spec_files = spec_files
+      @dir_mappings = dir_mappings
+      @jasmine_files = jasmine_files
+
+      @selenium_pid = nil
+      @jasmine_server_pid = nil
+    end
+
+    def start
+      start_servers
+      @client = Jasmine::SimpleClient.new("localhost", @selenium_server_port, "*firefox", "http://localhost:#{@jasmine_server_port}/")
+      @client.connect
+    end
+
+    def stop
+      @client.disconnect
+      stop_servers
+    end
+
+    def start_servers
+      @jasmine_server_port = Jasmine::find_unused_port
+      @selenium_server_port = Jasmine::find_unused_port
+
+      @selenium_pid = fork do
+        Process.setpgrp
+        exec "java -jar #{@selenium_jar_path} -port #{@selenium_server_port} > /dev/null 2>&1"
+      end
+      puts "selenium started.  pid is #{@selenium_pid}"
+
+      @jasmine_server_pid = fork do
+        Process.setpgrp
+        Jasmine::SimpleServer.start(@jasmine_server_port, @spec_files, @dir_mappings, @jasmine_files)
+        exit! 0
+      end
+      puts "jasmine server started.  pid is #{@jasmine_server_pid}"
+
+      Jasmine::wait_for_listener(@selenium_server_port, "selenium server")
+      Jasmine::wait_for_listener(@jasmine_server_port, "jasmine server")
+    end
+
+    def stop_servers
+      puts "shutting down the servers..."
+      Jasmine::kill_process_group(@selenium_pid) if @selenium_pid
+      Jasmine::kill_process_group(@jasmine_server_pid) if @jasmine_server_pid
+    end
+
+    def run
+      begin
+        start
+        puts "servers are listening on their ports -- running the test script..."
+        tests_passed = @client.run
+      ensure
+        stop
+      end
+      return tests_passed
+    end
+
+    def eval_js(script)
+      @client.eval_js(script)
+    end
+  end
+end

data/vendor/jasmine/contrib/ruby/jasmine_spec_builder.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "jasmine_runner.rb"))
+
+module Jasmine
+
+  class SpecBuilder
+    attr_accessor :suites
+
+    def initialize(spec_files, runner)
+      @spec_files = spec_files
+      @runner = runner
+    end
+
+    def start
+      guess_example_locations
+
+      @runner.start
+      load_suite_info
+      @spec_results = {}
+    end
+
+    def stop
+      @runner.stop
+    end
+
+    def script_path
+      File.expand_path(__FILE__)
+    end
+
+    def guess_example_locations
+      @example_locations = {}
+
+      example_name_parts = []
+      previous_indent_level = 0
+      @spec_files.each do |filename|
+        line_number = 1
+        File.open(filename, "r") do |file|
+          file.readlines.each do |line|
+            match = /^(\s*)(describe|it)\s*\(\s*["'](.*)["']\s*,\s*function/.match(line)
+            if (match)
+              indent_level = match[1].length / 2
+              example_name = match[3]
+              example_name_parts[indent_level] = example_name
+
+              full_example_name = example_name_parts.slice(0, indent_level + 1).join(" ")
+              @example_locations[full_example_name] = "#{filename}:#{line_number}: in `it'"
+            end
+            line_number += 1
+          end
+        end
+      end
+    end
+
+    def load_suite_info
+      started = Time.now
+      while !eval_js('jsApiReporter && jsApiReporter.started') do
+        raise "couldn't connect to Jasmine after 60 seconds" if (started + 60 < Time.now)
+        sleep 0.1
+      end
+
+      @suites = eval_js('JSON.stringify(jsApiReporter.suites)')
+    end
+
+    def results_for(spec_id)
+      spec_id = spec_id.to_s
+      return @spec_results[spec_id] if @spec_results[spec_id]
+
+      @spec_results[spec_id] = eval_js("JSON.stringify(jsApiReporter.results[#{spec_id}])")
+      while @spec_results[spec_id].nil? do
+        sleep 0.1
+        @spec_results[spec_id] = eval_js("JSON.stringify(jsApiReporter.results[#{spec_id}])")
+      end
+
+      @spec_results[spec_id]
+    end
+
+    def declare_suites
+      me = self
+      suites.each do |suite|
+        declare_suite(self, suite)
+      end
+    end
+
+    def declare_suite(parent, suite)
+      me = self
+      parent.describe suite["name"] do
+        suite["children"].each do |suite_or_spec|
+          type = suite_or_spec["type"]
+          if type == "suite"
+            me.declare_suite(self, suite_or_spec)
+          elsif type == "spec"
+            me.declare_spec(self, suite_or_spec)
+          else
+            raise "unknown type #{type} for #{suite_or_spec.inspect}"
+          end
+        end
+      end
+    end
+
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+
+      backtrace = @example_locations[parent.description + " " + example_name]
+      parent.it example_name, {}, backtrace do
+        me.report_spec(spec["id"])
+      end
+    end
+
+    def report_spec(spec_id)
+      spec_results = results_for(spec_id)
+
+      out = ""
+      messages = spec_results['messages'].each do |message|
+        case
+          when message["type"] == "MessageResult"
+            puts message["text"]
+            puts "\n"
+          else
+            unless message["message"] =~ /^Passed.$/
+              STDERR << message["message"]
+              STDERR << "\n"
+
+              out << message["message"]
+              out << "\n"
+            end
+
+            unless message["passed_"]
+              stack_trace = message["trace"]["stack"].gsub(/<br \/>/, "\n").gsub(/<\/?b>/, " ")
+              STDERR << stack_trace.gsub(/\(.*\)@http:\/\/localhost:[0-9]+\/specs\//, "/spec/")
+              STDERR << "\n"
+            end
+        end
+
+      end
+      fail out unless spec_results['result'] == 'passed'
+      puts out unless out.empty?
+    end
+
+    private
+
+    def eval_js(js)
+      @runner.eval_js(js)
+    end
+  end
+end
+