jasmine-multi_json 1.3.1.1

data/lib/jasmine/selenium_driver.rb

@@ -0,0 +1,41 @@
+module Jasmine
+  class SeleniumDriver
+    def initialize(browser, http_address)
+      require 'selenium-webdriver'
+      selenium_server = if ENV['SELENIUM_SERVER']
+        ENV['SELENIUM_SERVER']
+      elsif ENV['SELENIUM_SERVER_PORT']
+        "http://localhost:#{ENV['SELENIUM_SERVER_PORT']}/wd/hub"
+      end
+      options = if browser == "firefox" && ENV["JASMINE_FIREBUG"]
+                  require File.join(File.dirname(__FILE__), "firebug/firebug")
+                  profile = Selenium::WebDriver::Firefox::Profile.new
+                  profile.enable_firebug
+                  {:profile => profile}
+                end || {}
+      @driver = if selenium_server
+        Selenium::WebDriver.for :remote, :url => selenium_server, :desired_capabilities => browser.to_sym
+      else
+        Selenium::WebDriver.for browser.to_sym, options
+      end
+      @http_address = http_address
+    end
+
+    def connect
+      @driver.navigate.to @http_address
+    end
+
+    def disconnect
+      @driver.quit
+    end
+
+    def eval_js(script)
+      result = @driver.execute_script(script)
+      MultiJson.load("{\"result\":#{result}}", :max_nesting => false)["result"]
+    end
+
+    def json_generate(obj)
+      MultiJson.dump(obj)
+    end
+  end
+end

data/lib/jasmine/server.rb

@@ -0,0 +1,20 @@
+module Jasmine
+  class Server
+    def initialize(port = 8888, application = nil)
+      @port = port
+      @application = application
+    end
+
+    def start
+      if Jasmine::Dependencies.legacy_rack?
+        handler = Rack::Handler.get('webrick')
+        handler.run(@application, :Port => @port, :AccessLog => [])
+      else
+        server = Rack::Server.new(:Port => @port, :AccessLog => [])
+        # workaround for Rack bug, when Rack > 1.2.1 is released Rack::Server.start(:app => Jasmine.app(self)) will work
+        server.instance_variable_set(:@app, @application)
+        server.start
+      end
+    end
+  end
+end

data/lib/jasmine/tasks/jasmine.rake

@@ -0,0 +1,55 @@
+namespace :jasmine do
+  task :require do
+    require 'jasmine'
+  end
+
+  task :require_json do
+    begin
+      require 'multi_json'
+    rescue LoadError
+      puts "You must have a JSON library installed to run jasmine:ci. Try \"gem install multi_json\""
+      exit
+    end
+  end
+
+  desc "Run continuous integration tests"
+  task :ci => ["jasmine:require_json", "jasmine:require"] do
+    if Jasmine::Dependencies.rspec2?
+      require "rspec"
+      require "rspec/core/rake_task"
+    else
+      require "spec"
+      require 'spec/rake/spectask'
+    end
+
+    if Jasmine::Dependencies.rspec2?
+      RSpec::Core::RakeTask.new(:jasmine_continuous_integration_runner) do |t|
+        t.rspec_opts = ["--colour", "--format", ENV['JASMINE_SPEC_FORMAT'] || "progress"]
+        t.verbose = true
+        if Jasmine::Dependencies.rails_3_asset_pipeline?
+          t.rspec_opts += ["-r #{File.expand_path(File.join(::Rails.root, 'config', 'environment'))}"]
+        end
+        t.pattern = [Jasmine.runner_filepath]
+      end
+    else
+      Spec::Rake::SpecTask.new(:jasmine_continuous_integration_runner) do |t|
+        t.spec_opts = ["--color", "--format", ENV['JASMINE_SPEC_FORMAT'] || "specdoc"]
+        t.verbose = true
+        t.spec_files = [Jasmine.runner_filepath]
+      end
+    end
+    Rake::Task["jasmine_continuous_integration_runner"].invoke
+  end
+
+  task :server => "jasmine:require" do
+    port = ENV['JASMINE_PORT'] || 8888
+    puts "your tests are here:"
+    puts "  http://localhost:#{port}/"
+    Jasmine.load_configuration_from_yaml
+    app = Jasmine::Application.app(Jasmine.config)
+    Jasmine::Server.new(port, app).start
+  end
+end
+
+desc "Run specs via server"
+task :jasmine => ['jasmine:server']

data/lib/jasmine/tasks/jasmine_rails3.rake

@@ -0,0 +1 @@
+task "jasmine:require" => [:environment]

data/lib/jasmine/version.rb

@@ -0,0 +1,3 @@
+module Jasmine
+  VERSION = "1.3.1.1"
+end

data/lib/jasmine/yaml_config_parser.rb

@@ -0,0 +1,54 @@
+module Jasmine
+  class YamlConfigParser
+    def initialize(path, pwd, path_expander = lambda {}, yaml_loader = lambda {})
+      @path = path
+      @path_expander = path_expander
+      @pwd = pwd
+      @yaml_loader = yaml_loader
+    end
+
+    def src_dir
+      return @pwd unless loaded_yaml['src_dir']
+      File.join(@pwd, loaded_yaml['src_dir'])
+    end
+
+    def spec_dir
+      return File.join(@pwd, 'spec', 'javascripts') unless loaded_yaml['spec_dir']
+      File.join(@pwd, loaded_yaml['spec_dir'])
+    end
+
+    def jasmine_dir
+      return nil unless loaded_yaml['jasmine_dir']
+      File.join(@pwd, loaded_yaml['jasmine_dir'])
+    end
+
+    def src_files
+      @path_expander.call(src_dir, loaded_yaml['src_files'] || [])
+    end
+
+    def jasmine_files
+      @path_expander.call(jasmine_dir, loaded_yaml['jasmine_files'] || [])
+    end
+
+    def jasmine_css_files
+      @path_expander.call(jasmine_dir, loaded_yaml['jasmine_css_files'] || [])
+    end
+
+    def spec_files
+      @path_expander.call(spec_dir, loaded_yaml['spec_files'] || [])
+    end
+
+    def helpers
+      @path_expander.call(spec_dir, loaded_yaml['helpers'] || [])
+    end
+
+    def css_files
+      @path_expander.call(src_dir, loaded_yaml['stylesheets'] || [])
+    end
+
+    private
+    def loaded_yaml
+      @yaml_loader.call(@path)
+    end
+  end
+end

data/lib/rack/jasmine/cache_control.rb

@@ -0,0 +1,20 @@
+module Rack
+  module Jasmine
+
+    class CacheControl
+      def initialize(app)
+        @app, @content_type = app
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        headers = Rack::Utils::HeaderHash.new(headers)
+        headers['Cache-Control'] ||= "max-age=0, private, must-revalidate"
+        headers['Pragma'] ||= "no-cache"
+        [status, headers, body]
+      end
+    end
+
+  end
+end
+

data/lib/rack/jasmine/focused_suite.rb

@@ -0,0 +1,17 @@
+module Rack
+  module Jasmine
+
+    class FocusedSuite
+      def initialize(runner_config)
+        @runner_config = runner_config
+      end
+
+      def call(env)
+        run_adapter = Rack::Jasmine::RunAdapter.new(@runner_config)
+        run_adapter.run(env["PATH_INFO"])
+      end
+    end
+
+  end
+end
+

data/lib/rack/jasmine/runner.rb

@@ -0,0 +1,27 @@
+module Rack
+  module Jasmine
+
+    class Runner
+      def initialize(page)
+        @page = page
+      end
+
+      def call(env)
+        @path = env["PATH_INFO"]
+        return not_found if @path != "/"
+        [
+          200,
+          { 'Content-Type' => 'text/html'},
+          [@page.render]
+        ]
+      end
+
+      def not_found
+        [404, {"Content-Type" => "text/plain",
+               "X-Cascade" => "pass"},
+               ["File not found: #{@path}\n"]]
+      end
+    end
+
+  end
+end

data/spec/application_integration_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe "Jasmine::Application" do
+
+  it "includes no-cache headers for specs" do
+    pending
+    get "/__spec__/example_spec.js"
+    last_response.headers.should have_key("Cache-Control")
+    last_response.headers["Cache-Control"].should == "max-age=0, private, must-revalidate"
+    last_response.headers['Pragma'].each do |key|
+      last_response.headers[key].should == 'no-cache'
+    end
+  end
+
+end

data/spec/application_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+#Rspec 1 doesn't correctly pass blocks to stubs, so skip (covered by integration tests)
+#https://groups.google.com/forum/?fromgroups=#!topic/rspec/XT7paH2asCo
+
+if Jasmine::Dependencies.rspec2?
+  describe "Jasmine::Application" do
+    it "should map paths provided by the config" do
+      handler1 = double(:handler1)
+      handler2 = double(:handler2)
+      app1 = double(:app1)
+      app2 = double(:app2)
+      rack_path_map = {"/foo" => lambda { handler1 }, "/bar" => lambda { handler2 }}
+      config = double(:config, :rack_path_map => rack_path_map, :rack_apps => [])
+      builder = double("Rack::Builder.new")
+      #Rack::Builder instance evals, so builder.run is invalid syntax,
+      #this is the only way to stub out the 'run' dsl it gives to the block.
+      Jasmine::Application.stub(:run).with(handler1).and_return(app1)
+      Jasmine::Application.stub(:run).with(handler2).and_return(app2)
+
+      builder.should_receive(:map).twice do |path, &app|
+        if path == '/foo'
+          app.call.should == app1
+        elsif path == '/bar'
+          app.call.should == app2
+        else
+          raise "Unexpected path passed"
+        end
+      end
+
+      Jasmine::Application.app(config, builder).should == builder
+    end
+    it "should run rack apps provided by the config" do
+      app1 = double(:app1)
+      app2 = double(:app2)
+      block = lambda { "foo" }
+      config = double(:config, :rack_path_map => [], :rack_apps => [[app1, nil], [app2, block]])
+      builder = double("Rack::Builder.new")
+      builder.should_receive(:use).with(app1)
+      builder.should_receive(:use).with(app2, &block)
+      Jasmine::Application.app(config, builder).should == builder
+    end
+  end
+end

data/spec/asset_expander_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Jasmine::AssetExpander do
+  it "expands asset files" do
+    bundled_asset = double(:bundled_asset,
+                           :to_a => ['asset1', 'asset2'],
+                           :pathname => double(:pathname, :to_s => '/some_src_dir/asset_file'))
+
+    bundled_asset_getter = lambda do |filepath, ext|
+      if filepath == 'asset_file' && ext == 'js'
+        bundled_asset
+      end
+    end
+
+    asset_path_getter = lambda do |asset|
+      if asset == 'asset1'
+        'asset1_path'
+      elsif asset == 'asset2'
+        'asset2_path'
+      end
+    end
+
+    expander = Jasmine::AssetExpander.new(bundled_asset_getter, asset_path_getter)
+    expanded_assets = expander.expand('/some_src_dir', 'asset_file')
+    expanded_assets.should == ['/asset_file?body=true',
+                               '/asset1_path?body=true',
+                               '/asset2_path?body=true']
+  end
+
+  it "return nil if no bundled asset is found" do
+    bundled_asset = nil
+    bundled_asset_getter = lambda do |filepath, ext|
+      if filepath == 'asset_file' && ext == 'js'
+        bundled_asset
+      end
+    end
+
+    expander = Jasmine::AssetExpander.new(bundled_asset_getter, lambda {})
+    expanded_assets = expander.expand('/some_src_dir', 'asset_file')
+    expanded_assets.should be_nil
+  end
+end

data/spec/asset_pipeline_mapper_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Jasmine::AssetPipelineMapper do
+  it "expands asset paths if available" do
+    expander = lambda do |dir, path|
+      if dir == "/some_location/" && path == 'asset1'
+        ['asset1', 'asset2']
+      elsif dir == "/some_location/" && path == 'asset2'
+        ['asset1', 'asset3']
+      end
+
+    end
+    config = double(:config, :src_dir => "/some_location/")
+
+    mapper = Jasmine::AssetPipelineMapper.new(config, expander)
+
+    mapper.map_src_paths(['asset1', 'asset2', 'asset4']).should == ['asset1', 'asset2', 'asset3', 'asset4']
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Jasmine do
+  it "should provide the root path" do
+    File.stub(:dirname).and_return('lib/jasmine')
+    File.should_receive(:expand_path) { |path| path }
+    Jasmine.root.should == 'lib/jasmine'
+  end
+  it "should append passed file paths" do
+    File.stub(:dirname).and_return('lib/jasmine')
+    File.should_receive(:expand_path) { |path| path }
+    Jasmine.root('subdir1', 'subdir2').should == File.join('lib/jasmine', 'subdir1', 'subdir2')
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Jasmine::Configuration do
+  let(:test_mapper1) do
+    Class.new do
+      def initialize(config)
+        @config = config
+      end
+      def map_src_paths(paths)
+        paths.map { |f| "mapped_src/#{f}" }
+      end
+      def map_jasmine_paths(paths)
+        paths.map { |f| "mapped_jasmine/#{f}" }
+      end
+      def map_spec_paths(paths)
+        paths.map { |f| "mapped_spec/#{f}" }
+      end
+      def map_boot_paths(paths)
+        paths.map { |f| "mapped_boot/#{f}" }
+      end
+    end
+  end
+  let(:test_mapper2) do
+    Class.new do
+      def initialize(config)
+        @config = config
+      end
+      def map_src_paths(paths)
+        paths.map { |f| "#{f}/src" }
+      end
+      def map_jasmine_paths(paths)
+        paths.map { |f| "#{f}/jasmine" }
+      end
+      def map_spec_paths(paths)
+        paths.map { |f| "#{f}/spec" }
+      end
+      def map_boot_paths(paths)
+        paths.map { |f| "#{f}/boot" }
+      end
+    end
+  end
+  let(:test_mapper3) do
+    Class.new do
+      def initialize(config)
+        @config = config
+      end
+    end
+  end
+
+  describe "returning css files" do
+    it "returns mapped jasmine_css_files + css_files" do
+      config = Jasmine::Configuration.new()
+      config.add_path_mapper(lambda { |c| test_mapper1.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper2.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper3.new(c) })
+      config.css_files.should == []
+      config.jasmine_css_files = lambda { ["jasmine_css"] }
+      config.css_files = lambda { ["css"] }
+      config.css_files.should == ['mapped_jasmine/jasmine_css/jasmine', 'mapped_src/css/src']
+    end
+  end
+
+  describe "returning javascript files" do
+    it "returns the jasmine core files, then srcs, then specs, then boot" do
+      config = Jasmine::Configuration.new()
+      config.add_path_mapper(lambda { |c| test_mapper1.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper2.new(c) })
+      config.add_path_mapper(lambda { |c| test_mapper3.new(c) })
+      config.js_files.should == []
+      config.jasmine_files = lambda { ['jasmine'] }
+      config.src_files = lambda  { ['src'] }
+      config.boot_files = lambda { ['boot'] }
+      config.spec_files = lambda { ['spec'] }
+      config.js_files.should == [
+        'mapped_jasmine/jasmine/jasmine',
+        'mapped_src/src/src',
+        'mapped_spec/spec/spec',
+        'mapped_boot/boot/boot',
+      ]
+    end
+  end
+
+  describe "returning rack map" do
+    it "permits arbitrary rack app path mapping" do
+      config = Jasmine::Configuration.new()
+      result = double
+      config.add_rack_path('some/path', lambda { result })
+      map = config.rack_path_map
+      map['some/path'].should be
+      map['some/path'].call.should == result
+    end
+
+  end
+
+  describe "rack apps" do
+    it "permits the addition of arbitary rack apps" do
+      config = Jasmine::Configuration.new()
+      app = double
+      config.add_rack_app(app)
+      config.rack_apps.should == [[app, nil]]
+    end
+    it "permits the addition of arbitary rack apps with arbitrary config" do
+      config = Jasmine::Configuration.new()
+      app = double
+      block = lambda { "foo" }
+      config.add_rack_app(app, &block)
+      config.rack_apps.should == [[app, block]]
+    end
+  end
+
+  describe "port" do
+    it "returns new port and caches return value" do
+      config = Jasmine::Configuration.new()
+      Jasmine.stub(:find_unused_port).and_return('1234')
+      config.port.should == '1234'
+      Jasmine.stub(:find_unused_port).and_return('4321')
+      config.port.should == '1234'
+    end
+    it "returns port if configured" do
+      config = Jasmine::Configuration.new()
+      config.port = '5678'
+      Jasmine.stub(:find_unused_port).and_return('1234')
+      config.port.should == '5678'
+    end
+  end
+
+  describe "browser" do
+    it "should default to firefox" do
+      Jasmine::Configuration.new().browser.should == 'firefox'
+    end
+
+    it "returns browser if set" do
+      config = Jasmine::Configuration.new()
+      config.browser = 'foo'
+      config.browser.should == 'foo'
+    end
+  end
+
+  describe "result_batch_size" do
+    it "should default to 50" do
+      Jasmine::Configuration.new().result_batch_size.should == 50
+    end
+
+    it "returns result_batch_size if set" do
+      config = Jasmine::Configuration.new()
+      config.result_batch_size = 25
+      config.result_batch_size.should == 25
+    end
+  end
+
+  describe "host" do
+    it "should default to localhost" do
+      Jasmine::Configuration.new().host.should == 'http://localhost'
+    end
+
+    it "returns host if set" do
+      config = Jasmine::Configuration.new()
+      config.host = 'foo'
+      config.host.should == 'foo'
+    end
+  end
+end
+