js_spec 0.2.1 → 0.3.0

data/lib/js_spec/client.rb

@@ -1,50 +0,0 @@
-module JsSpec
-  class Client
-    class << self
-      def run(params={})
-        data = []
-        data << "selenium_host=#{CGI.escape(params[:selenium_host] || 'localhost')}"
-        data << "selenium_port=#{CGI.escape((params[:selenium_port] || 4444).to_s)}"
-        data << "spec_url=#{CGI.escape(params[:spec_url])}" if params[:spec_url]
-        response = Net::HTTP.start(DEFAULT_HOST, DEFAULT_PORT) do |http|
-          http.post('/runners/firefox', data.join("&"))
-        end
-
-        body = response.body
-        if body.empty?
-          puts "SUCCESS"
-          return true
-        else
-          puts "FAILURE"
-          puts body
-          return false
-        end
-      end
-
-      def run_argv(argv)
-        params = {}
-        parser = OptionParser.new do |o|
-          o.banner = "JsSpec Runner"
-          o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
-
-          o.on
-          o.on('-h', '--selenium_host=SELENIUM_HOST', "The host name of the Selenium Server relative to where this file is executed") do |host|
-            params[:selenium_host] = host
-          end
-
-          o.on('-p', '--selenium_port=SELENIUM_PORT', "The port of the Selenium Server relative to where this file is executed") do |port|
-            params[:selenium_port] = port
-          end
-
-          o.on('-u', '--spec_url=SPEC_URL', "The url of the js spec server, relative to the browsers running via the Selenium Server") do |spec_url|
-            params[:spec_url] = spec_url
-          end
-
-          o.on_tail
-        end
-        parser.order!(argv)
-        run params
-      end
-    end
-  end
-end

data/lib/js_spec/guid.rb

@@ -1,153 +0,0 @@
-#
-# Guid - Ruby library for portable GUID/UUID generation.
-#
-# Copyright (c) 2004 David Garamond <davegaramond at icqmail com>
-#
-# This library is free software; you can redistribute it and/or modify it
-# under the same terms as Ruby itself.
-#
-
-if RUBY_PLATFORM =~ /[^r]win/i &&
-  module Guid_Win32_
-    require 'Win32API'
-
-    PROV_RSA_FULL       = 1
-    CRYPT_VERIFYCONTEXT = 0xF0000000
-    FORMAT_MESSAGE_IGNORE_INSERTS  = 0x00000200
-    FORMAT_MESSAGE_FROM_SYSTEM     = 0x00001000
-
-    CryptAcquireContext = Win32API.new("advapi32", "CryptAcquireContext",
-                                       'PPPII', 'L')
-    CryptGenRandom = Win32API.new("advapi32", "CryptGenRandom",
-                                  'LIP', 'L')
-    CryptReleaseContext = Win32API.new("advapi32", "CryptReleaseContext",
-                                       'LI', 'L')
-    GetLastError = Win32API.new("kernel32", "GetLastError", '', 'L')
-    FormatMessageA = Win32API.new("kernel32", "FormatMessageA",
-                                  'LPLLPLPPPPPPPP', 'L')
-
-    def lastErrorMessage
-      code = GetLastError.call
-      msg = "\0" * 1024
-      len = FormatMessageA.call(FORMAT_MESSAGE_IGNORE_INSERTS +
-                                FORMAT_MESSAGE_FROM_SYSTEM, 0,
-                                code, 0, msg, 1024, nil, nil,
-                                nil, nil, nil, nil, nil, nil)
-      msg[0, len].tr("\r", '').chomp
-    end
-
-    def initialize
-      hProvStr = " " * 4
-      if CryptAcquireContext.call(hProvStr, nil, nil, PROV_RSA_FULL,
-                                  CRYPT_VERIFYCONTEXT) == 0
-        raise SystemCallError, "CryptAcquireContext failed: #{lastErrorMessage}"
-      end
-      hProv, = hProvStr.unpack('L')
-      @bytes = " " * 16
-      if CryptGenRandom.call(hProv, 16, @bytes) == 0
-        raise SystemCallError, "CryptGenRandom failed: #{lastErrorMessage}"
-      end
-      if CryptReleaseContext.call(hProv, 0) == 0
-        raise SystemCallError, "CryptReleaseContext failed: #{lastErrorMessage}"
-      end
-    end
-  end
-end
-
-module Guid_Unix_
-  @@random_device = nil
-
-  def initialize
-    if !@@random_device
-      if File.exists? "/dev/urandom"
-        @@random_device = File.open "/dev/urandom", "r"
-      elsif File.exists? "/dev/random"
-        @@random_device = File.open "/dev/random", "r"
-      else
-        raise RuntimeError, "Can't find random device"
-      end
-    end
-
-    @bytes = @@random_device.read(16)
-  end
-end
-
-class Guid
-  if RUBY_PLATFORM =~ /[^r]win/
-    include Guid_Win32_
-  else
-    include Guid_Unix_
-  end
-
-  def hexdigest
-    @bytes.unpack("h*")[0]
-  end
-
-  def to_s
-    @bytes.unpack("h8 h4 h4 h4 h12").join "-"
-  end
-
-  def inspect
-    to_s
-  end
-
-  def raw
-    @bytes
-  end
-
-  def self.from_s(s)
-    raise ArgumentError, "Invalid GUID hexstring" unless
-      s =~ /\A[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}\z/i
-    guid = Guid.allocate
-    guid.instance_eval { @bytes = [s.gsub(/[^0-9a-f]+/i, '')].pack "h*" }
-    guid
-  end
-
-  def self.from_raw(bytes)
-    raise ArgumentError, "Invalid GUID raw bytes, length must be 16 bytes" unless
-      bytes.length == 16
-    guid = Guid.allocate
-    guid.instance_eval { @bytes = bytes }
-    guid
-  end
-
-  def ==(other)
-    @bytes == other.raw
-  end
-end
-
-if __FILE__ == $0
-  require 'test/unit'
-
-  class GuidTest < Test::Unit::TestCase
-    def test_new
-      g = Guid.new
-
-      # different representations of guid: hexdigest, hex+dashes, raw bytes
-      assert_equal(0, g.to_s =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/)
-      assert_equal(16, g.raw.length)
-      assert_equal(0, g.hexdigest =~ /\A[0-9a-f]{32}\z/)
-      assert_equal(g.hexdigest, g.to_s.gsub(/-/, ''))
-
-      # must be different each time we produce (this is just a simple test)
-      g2 = Guid.new
-      assert_equal(true, g != g2)
-      assert_equal(true, g.to_s != g2.to_s)
-      assert_equal(true, g.raw != g2.raw)
-      assert_equal(true, g.hexdigest != g2.hexdigest)
-      assert_equal(1000, (1..1000).select { |i| g != Guid.new }.length)
-    end
-
-    def test_from_s
-      g = Guid.new
-      g2 = Guid.from_s(g.to_s)
-      assert_equal(g, g2)
-    end
-
-    def test_from_raw
-      g = Guid.new
-      g2 = Guid.from_raw(g.raw)
-      assert_equal(g, g2)
-    end
-  end
-end

data/lib/js_spec/rack/commonlogger.rb

@@ -1,5 +0,0 @@
-Rack::CommonLogger.class_eval do
-  def empty?
-    @body.empty?
-  end
-end

data/lib/js_spec/rack.rb

@@ -1,2 +0,0 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/rack/commonlogger"

data/lib/js_spec/rails_server.rb

@@ -1,22 +0,0 @@
-module JsSpec
-  class RailsServer < Server
-    class << self
-      def run(rails_root, server_options = {})
-        server_options[:Host] ||= DEFAULT_HOST
-        server_options[:Port] ||= DEFAULT_PORT
-        Server.instance = new(rails_root, server_options[:Host], server_options[:Port])
-        Server.instance.run server_options
-      end
-    end
-
-    def initialize(rails_root, host=DEFAULT_HOST, port=DEFAULT_PORT)
-      super(
-        "#{rails_root}/spec/javascripts",
-        "#{rails_root}/public/javascripts",
-        "#{rails_root}/public",
-        host,
-        port
-      )
-    end
-  end
-end

data/lib/js_spec/resources/dir.rb

@@ -1,60 +0,0 @@
-module JsSpec
-  module Resources
-    class Dir < File
-      def locate(name)
-        if file = file(name)
-          file
-        else
-          locate_spec_runner(name)
-        end
-      end
-
-      def get(request, response)
-        SpecDirRunner.new(self).get(request, response)
-      end
-
-      def glob(pattern)
-        expanded_pattern = absolute_path + pattern
-        ::Dir.glob(expanded_pattern).map do |absolute_globbed_path|
-          relative_globbed_path = absolute_globbed_path.gsub(absolute_path, relative_path)
-          File.new(absolute_globbed_path, relative_globbed_path)
-        end
-      end
-
-      protected
-      def determine_child_paths(name)
-        absolute_child_path = "#{absolute_path}/#{name}"
-        relative_child_path = "#{relative_path}/#{name}"
-        [absolute_child_path, relative_child_path]
-      end
-
-      def locate_spec_runner(name)
-        if subdir = subdir(name)
-          subdir
-        elsif file = file(name + '.js')
-          SpecFileRunner.new(file)
-        else
-          raise "No specs found at #{relative_path}/#{name}."
-        end
-      end
-
-      def file(name)
-        absolute_file_path, relative_file_path = determine_child_paths(name)
-        if ::File.exists?(absolute_file_path) && !::File.directory?(absolute_file_path)
-          Resources::File.new(absolute_file_path, relative_file_path)
-        else
-          nil
-        end
-      end
-
-      def subdir(name)
-        absolute_dir_path, relative_dir_path = determine_child_paths(name)
-        if ::File.directory?(absolute_dir_path)
-          Resources::Dir.new(absolute_dir_path, relative_dir_path)
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/js_spec/resources/file.rb

@@ -1,32 +0,0 @@
-module JsSpec
-  module Resources
-    class File
-      MIME_TYPES = {
-      '.js' => 'text/javascript',
-      '.css' => 'text/css',
-      '.png' => 'image/png',
-      '.jpg' => 'image/jpeg',
-      '.jpeg' => 'image/jpeg',
-      '.gif' => 'image/gif',
-      }
-
-      attr_reader :absolute_path, :relative_path
-
-      def initialize(absolute_path, relative_path)
-        @absolute_path = absolute_path
-        @relative_path = relative_path
-      end
-
-      def get(request, response)
-        extension = ::File.extname(absolute_path)
-        response.headers['Content-Type'] = MIME_TYPES[extension] || 'text/html'
-        response.body = ::File.read(absolute_path)
-      end
-
-      def ==(other)
-        return false unless other.class == self.class
-        absolute_path == other.absolute_path && relative_path == other.relative_path
-      end
-    end
-  end
-end

data/lib/js_spec/resources/runners/firefox_runner.rb

@@ -1,71 +0,0 @@
-module JsSpec
-  module Resources
-    class Runners
-      class FirefoxRunner
-        class << self
-          def resume(guid, text)
-            runner = instances.delete(guid)
-            runner.finalize(text)
-          end
-
-          def register_instance(runner)
-            instances[runner.guid] = runner
-          end
-
-          protected
-          def instances
-            @instances ||= {}
-          end
-        end
-
-        include FileUtils
-        attr_reader :guid, :profile_dir, :request, :response, :connection, :driver
-
-        def initialize(request, response)
-          profile_base = "#{::Dir.tmpdir}/js_spec/firefox"
-          mkdir_p profile_base
-          @profile_dir = "#{profile_base}/#{Time.now.to_i}"
-          @guid = Guid.new.to_s
-          @request = request
-          @response = response
-          @connection = Server.connection
-        end
-
-        def post(request, response)
-          FirefoxRunner.register_instance self
-          spec_url = (request && request['spec_url']) ? request['spec_url'] : spec_suite_url
-          parsed_spec_url = URI.parse(spec_url)
-          selenium_port = (request['selenium_port'] || 4444).to_i
-          @driver = Selenium::SeleniumDriver.new(
-            request['selenium_host'] || 'localhost',
-            selenium_port,
-            '*firefox',
-            "#{parsed_spec_url.scheme}://#{parsed_spec_url.host}:#{parsed_spec_url.port}"
-          )
-          begin
-            driver.start
-          rescue Errno::ECONNREFUSED => e
-            raise Errno::ECONNREFUSED, "Cannot connect to Selenium Server on port #{selenium_port}. To start the selenium server, run `selenium`."
-          end
-          Thread.start do
-            url = "#{spec_url}?guid=#{guid}"
-            driver.open(url)
-          end
-          response.status = 200
-        end
-
-        def finalize(text)
-          driver.stop
-          response.body = text
-          connection.send_body(response)
-        end
-
-        protected
-
-        def spec_suite_url
-          "#{Server.root_url}/specs"
-        end
-      end
-    end
-  end
-end

data/lib/js_spec/resources/runners.rb

@@ -1,15 +0,0 @@
-dir = File.dirname(__FILE__)
-
-module JsSpec
-  module Resources
-    class Runners
-      def locate(name)
-        if name == 'firefox'
-          FirefoxRunner.new(Server.request, Server.response)
-        else
-          raise "Invalid path #{name}"
-        end
-      end
-    end
-  end
-end

data/lib/js_spec/resources/spec_dir_runner.rb

@@ -1,15 +0,0 @@
-module JsSpec
-  module Resources
-    class SpecDirRunner < SpecRunner
-      attr_reader :dir
-
-      def initialize(dir)
-        @dir = dir
-      end
-
-      def spec_files
-        dir.glob("/**/*_spec.js")
-      end
-    end
-  end
-end

data/lib/js_spec/resources/spec_file_runner.rb

@@ -1,15 +0,0 @@
-module JsSpec
-  module Resources
-    class SpecFileRunner < SpecRunner
-      attr_reader :file
-
-      def initialize(file)
-        @file = file
-      end
-
-      def spec_files
-        [file]
-      end
-    end
-  end
-end

data/lib/js_spec/resources/suite.rb

@@ -1,24 +0,0 @@
-module JsSpec
-  module Resources
-    class Suite
-      class << self
-        def locate(id)
-          new id
-        end
-      end
-
-      attr_reader :id
-      def initialize(id)
-        @id = id
-      end
-
-      def locate(name)
-        if name == 'finish'
-          SuiteFinish.new self
-        else
-          raise ArgumentError, "Invalid path: #{name}"
-        end
-      end
-    end
-  end
-end

data/lib/js_spec/resources/suite_finish.rb

@@ -1,20 +0,0 @@
-module JsSpec
-  module Resources
-    class SuiteFinish
-      attr_reader :suite
-      def initialize(suite)
-        @suite = suite
-      end
-
-      def post(request, response)
-        guid = request['guid']
-        if guid
-          Runners::FirefoxRunner.resume(guid, request['text'])
-        else
-          STDOUT.puts request['text']
-        end
-        ""
-      end
-    end
-  end
-end

data/lib/js_spec/resources/web_root.rb

@@ -1,34 +0,0 @@
-module JsSpec
-  module Resources
-    class WebRoot
-      attr_reader :public_path
-      def initialize(public_path)
-        @public_path = ::File.expand_path(public_path)
-      end
-
-      def locate(name)
-        case name
-        when 'specs'
-          Resources::Dir.new(JsSpec::Server.spec_root_path, "/specs")
-        when 'core'
-          Resources::Dir.new(JsSpec::Server.core_path, "/core")
-        when 'implementations'
-          Resources::Dir.new(JsSpec::Server.implementation_root_path, "/implementations")
-        when 'suites'
-          Resources::Suite
-        when 'runners'
-          Resources::Runners.new
-        else
-          potential_file_in_public_path = "#{public_path}/#{name}"
-          if ::File.directory?(potential_file_in_public_path)
-            Resources::Dir.new(potential_file_in_public_path, "/#{name}")
-          elsif ::File.exists?(potential_file_in_public_path)
-            Resources::File.new(potential_file_in_public_path, "/#{name}")
-          else
-            raise "Invalid path: #{name}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/js_spec/server.rb

@@ -1,98 +0,0 @@
-module JsSpec
-  class Server
-    class << self
-      attr_accessor :instance
-
-      def run(spec_root_path, implementation_root_path, public_path, server_options = {})
-        server_options[:Host] ||= DEFAULT_HOST
-        server_options[:Port] ||= DEFAULT_PORT
-        @instance = new(spec_root_path, implementation_root_path, public_path, server_options[:Host], server_options[:Port])
-        instance.run server_options
-      end
-
-      def spec_root_path; instance.spec_root_path; end
-      def implementation_root_path; instance.implementation_root_path; end
-      def public_path; instance.public_path; end
-      def core_path; instance.core_path; end
-      def connection; instance.connection; end
-      def request; instance.request; end
-      def response; instance.response; end
-      def root_url; instance.root_url; end
-    end
-
-    attr_reader :host, :port, :spec_root_path, :implementation_root_path, :core_path, :public_path
-
-    def initialize(spec_root_path, implementation_root_path, public_path, host=DEFAULT_HOST, port=DEFAULT_PORT)
-      dir = ::File.dirname(__FILE__)
-      @core_path = ::File.expand_path("#{dir}/../../core")
-      @spec_root_path = ::File.expand_path(spec_root_path)
-      @implementation_root_path = ::File.expand_path(implementation_root_path)
-      @public_path = ::File.expand_path(public_path)
-      @host = host
-      @port = port
-    end
-
-    def run(options)
-      server = ::Thin::Server.new(options[:Host], options[:Port], self)
-      server.backend = ::Thin::Backends::JsSpecServer.new(options[:Host], options[:Port])
-      server.backend.server = server
-      server.start!
-    end
-
-    def call(env)
-      self.connection = env['js_spec.connection']
-      self.request = Rack::Request.new(env)
-      self.response = Rack::Response.new
-      method = request.request_method.downcase.to_sym
-      get_resource(request).send(method, request, response)
-      response.finish
-    ensure
-      self.connection = nil
-      self.request = nil
-      self.response = nil
-    end
-
-    def connection
-      Thread.current[:connection]
-    end
-
-    def request
-      Thread.current[:request]
-    end
-
-    def response
-      Thread.current[:response]
-    end
-
-    def root_url
-      "http://#{host}:#{port}"
-    end
-    
-    protected
-    def connection=(connection)
-      Thread.current[:connection] = connection
-    end
-
-    def request=(request)
-      Thread.current[:request] = request
-    end
-
-    def response=(response)
-      Thread.current[:response] = response
-    end
-
-    def path_parts(req)
-      request.path_info.split('/').reject { |part| part == "" }
-    end
-
-    def get_resource(request)
-      path_parts(request).inject(Resources::WebRoot.new(public_path)) do |resource, child_resource_name|
-        resource.locate(child_resource_name)
-      end
-    rescue Exception => e
-      detailed_exception = Exception.new("Error handling path #{request.path_info}\n#{e.message}")
-      detailed_exception.set_backtrace(e.backtrace)
-      raise detailed_exception
-    end
-  end
-end

data/lib/js_spec/thin/backends/js_spec_server.rb

@@ -1,9 +0,0 @@
-module Thin
-  module Backends
-    class JsSpecServer < TcpServer
-      def connect
-        @signature = EventMachine.start_server(@host, @port, JsSpecConnection, &method(:initialize_connection))
-      end
-    end
-  end
-end

data/lib/js_spec/thin/js_spec_connection.rb

@@ -1,42 +0,0 @@
-module Thin
-  class JsSpecConnection < Connection
-    def process
-      # Add client info to the request env
-      @request.remote_address = remote_address
-
-      env = @request.env
-      env['js_spec.connection'] = self
-      @response.status, @response.headers, @response.body = @app.call(env)
-      send_data @response.head
-      unless @response.body.empty?
-        send_body @response.body
-      end
-    rescue Exception => e
-      handle_error e
-    end
-
-    def send_body(rack_response)
-      rack_response.each do |chunk|
-        send_data chunk
-      end
-      # If no more request on that same connection, we close it.
-      close_connection_after_writing unless persistent?
-    rescue Exception => e
-      handle_error e
-    ensure
-      @request.close  rescue nil
-      @response.close rescue nil
-
-      # Prepare the connection for another request if the client
-      # supports HTTP pipelining (persistent connection).
-      post_init if persistent?
-    end
-
-    def handle_error(error)
-      log "!! Unexpected error while processing request: #{error.message}"
-      log error.backtrace
-      log_error
-      close_connection rescue nil
-    end
-  end
-end

data/lib/js_spec/thin.rb

@@ -1,3 +0,0 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/thin/js_spec_connection"
-require "#{dir}/thin/backends/js_spec_server"