jasmine 1.3.0 → 1.3.1

data/lib/jasmine/core_configuration.rb

@@ -0,0 +1,28 @@
+module Jasmine
+  class CoreConfiguration
+    def initialize(core = Jasmine::Core)
+      @core = core
+    end
+
+    def path
+      @core.path
+    end
+
+    #TODO: maybe this doesn't belong in CoreConfig
+    def boot_path
+      Jasmine.root('javascripts')
+    end
+
+    def boot_files
+      Dir.glob(File.join(boot_path, "**"))
+    end
+
+    def js_files
+      @core.js_files
+    end
+
+    def css_files
+      @core.css_files
+    end
+  end
+end

data/lib/jasmine/javascripts/boot.js

@@ -0,0 +1,28 @@
+var jsApiReporter;
+(function() {
+  var jasmineEnv = jasmine.getEnv();
+
+  jsApiReporter = new jasmine.JsApiReporter();
+  var htmlReporter = new jasmine.HtmlReporter();
+
+  jasmineEnv.addReporter(jsApiReporter);
+  jasmineEnv.addReporter(htmlReporter);
+
+  jasmineEnv.specFilter = function(spec) {
+    return htmlReporter.specFilter(spec);
+  };
+
+  var currentWindowOnload = window.onload;
+
+  window.onload = function() {
+    if (currentWindowOnload) {
+      currentWindowOnload();
+    }
+    execJasmine();
+  };
+
+  function execJasmine() {
+    jasmineEnv.execute();
+  }
+
+})();

data/lib/jasmine/path_expander.rb

@@ -0,0 +1,18 @@
+module Jasmine
+  class PathExpander
+
+    def self.expand(base_directory, patterns, globber = Dir.method(:glob))
+      negative, positive = patterns.partition {|pattern| /^!/ =~ pattern}
+      chosen, negated = [positive, negative].collect do |patterns|
+        patterns.map do |path|
+          files = globber.call(File.join(base_directory, path.gsub(/^!/, '')))
+          if files.empty? && !(path =~ /\*|^\!/)
+            files = [File.join(base_directory, path)]
+          end
+          files
+        end.flatten.uniq
+      end
+      chosen - negated
+    end
+  end
+end

data/lib/jasmine/path_mapper.rb

@@ -0,0 +1,29 @@
+module Jasmine
+  class PathMapper
+    def initialize(config)
+      @config = config
+    end
+
+    def map_src_paths(paths)
+      map(paths, @config.src_dir, @config.src_path)
+    end
+
+    def map_spec_paths(paths)
+      map(paths, @config.spec_dir, @config.spec_path)
+    end
+
+    def map_boot_paths(paths)
+      map(paths, @config.boot_dir, @config.boot_path)
+    end
+
+    def map_jasmine_paths(paths)
+      map(paths, @config.jasmine_dir, @config.jasmine_path)
+    end
+
+    private
+    def map(paths, remove_path, add_path)
+      paths.map { |path| File.join(add_path, (path.gsub(remove_path, ''))) }
+    end
+
+  end
+end

data/lib/jasmine/results_processor.rb

@@ -10,27 +10,28 @@ module Jasmine
     end
 
     def example_locations
-      example_locations = {}
-      example_name_parts = []
-      previous_indent_level = 0
-      @config.spec_files_full_paths.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
+      # example_locations = {}
+      # example_name_parts = []
+      # previous_indent_level = 0
+      # @config.spec_files_full_paths.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
-      example_locations
+               # 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
+      # example_locations
+      {}
     end
 
   end

data/lib/jasmine/run.html.erb

@@ -7,43 +7,6 @@
   <% css_files.each do |css_file| %>
     <link rel="stylesheet" href="<%= css_file %>" type="text/css" media="screen"/>
   <% end %>
-
-  <% jasmine_files.each do |jasmine_file| %>
-  <script src="<%= jasmine_file %>" type="text/javascript"></script>
-  <% end %>
-
-  <script type="text/javascript">
-    //TODO: make this a js file that gets passed in, then iterate over only js_files
-    var jsApiReporter;
-    (function() {
-      var jasmineEnv = jasmine.getEnv();
-
-      jsApiReporter = new jasmine.JsApiReporter();
-      var htmlReporter = new jasmine.HtmlReporter();
-
-      jasmineEnv.addReporter(jsApiReporter);
-      jasmineEnv.addReporter(htmlReporter);
-
-      jasmineEnv.specFilter = function(spec) {
-        return htmlReporter.specFilter(spec);
-      };
-
-      var currentWindowOnload = window.onload;
-
-      window.onload = function() {
-        if (currentWindowOnload) {
-          currentWindowOnload();
-        }
-        execJasmine();
-      };
-
-      function execJasmine() {
-        jasmineEnv.execute();
-      }
-
-    })();
-  </script>
-
   <% js_files.each do |js_file| %>
   <script src="<%= js_file %>" type="text/javascript"></script>
   <% end %>

data/lib/jasmine/run_specs.rb

@@ -2,18 +2,22 @@ $:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing
 
 require 'rubygems'
 require 'jasmine'
-jasmine_config_overrides = File.expand_path(File.join(Dir.pwd, 'spec', 'javascripts', 'support', 'jasmine_config.rb'))
-require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
 if Jasmine::Dependencies.rspec2?
   require 'rspec'
 else
   require 'spec'
 end
 
-jasmine_runner_config = Jasmine::RunnerConfig.new
-server = Jasmine::Server.new(jasmine_runner_config.port, Jasmine::Application.app(jasmine_runner_config))
-client = Jasmine::SeleniumDriver.new(jasmine_runner_config.browser, jasmine_runner_config.jasmine_server_url)
+jasmine_yml = File.join(Dir.pwd, 'spec', 'javascripts', 'support', 'jasmine.yml')
+if File.exist?(jasmine_yml)
+end
+
+Jasmine.load_configuration_from_yaml
+
+config = Jasmine.config
 
+server = Jasmine::Server.new(config.port, Jasmine::Application.app(config))
+driver = Jasmine::SeleniumDriver.new(config.browser, "#{config.host}:#{config.port}/")
 t = Thread.new do
   begin
     server.start
@@ -22,11 +26,11 @@ t = Thread.new do
   # # ignore bad exits
 end
 t.abort_on_exception = true
-Jasmine::wait_for_listener(jasmine_runner_config.port, "jasmine server")
+Jasmine::wait_for_listener(config.port, "jasmine server")
 puts "jasmine server started."
 
-results_processor = Jasmine::ResultsProcessor.new(jasmine_runner_config)
-results = Jasmine::Runners::HTTP.new(client, results_processor, jasmine_runner_config.result_batch_size).run
+results_processor = Jasmine::ResultsProcessor.new(config)
+results = Jasmine::Runners::HTTP.new(driver, results_processor, config.result_batch_size).run
 formatter = Jasmine::RspecFormatter.new
 formatter.format_results(results)
 

data/lib/jasmine/server.rb

@@ -1,6 +1,6 @@
 module Jasmine
   class Server
-    def initialize(port = 8888, application = Jasmine::Application.app)
+    def initialize(port = 8888, application = nil)
       @port = port
       @application = application
     end

data/lib/jasmine/tasks/jasmine.rake

@@ -42,13 +42,12 @@ namespace :jasmine do
   end
 
   task :server => "jasmine:require" do
-    jasmine_config_overrides = File.join(Jasmine::Config.new.project_root, 'spec', 'javascripts' ,'support' ,'jasmine_config.rb')
-    require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
-
     port = ENV['JASMINE_PORT'] || 8888
     puts "your tests are here:"
     puts "  http://localhost:#{port}/"
-    Jasmine::Server.new(port).start
+    Jasmine.load_configuration_from_yaml
+    app = Jasmine::Application.app(Jasmine.config)
+    Jasmine::Server.new(port, app).start
   end
 end
 

data/lib/jasmine/version.rb

@@ -1,3 +1,3 @@
 module Jasmine
-  VERSION = "1.3.0"
+  VERSION = "1.3.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/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

@@ -1,99 +1,44 @@
 require 'spec_helper'
-require 'rack/test'
 
-describe "Jasmine::Application" do
-  include Rack::Test::Methods
-
-  def app
-    @root = File.join(File.dirname(__FILE__))
-    runner_config = double("config",
-                    :project_root => @root,
-                    :spec_dir => File.join(@root, "fixture", "spec"),
-                    :spec_path => "/__spec__",
-                    :root_path => "/__root__",
-                    :css_files => [],
-                    :jasmine_files => [],
-                    :js_files => ["path/file1.js", "path/file2.js"],
-                    :src_dir => File.join(@root, "fixture", "src"),
-                    :src_files => ["file1.js"],
-                    :spec_files => ["example_spec.js"])
-    Jasmine::Application.app(runner_config)
-  end
-
-  it "includes no-cache headers for specs" do
-    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"
-  end
-
-  it "should serve static files from spec dir under __spec__" do
-    get "/__spec__/example_spec.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "application/javascript"
-    last_response.body.should == File.read(File.join(@root, "fixture/spec/example_spec.js"))
-    end
-
-  it "should serve static files from root dir under __root__" do
-    get "/__root__/fixture/src/example.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "application/javascript"
-    last_response.body.should == File.read(File.join(@root, "fixture/src/example.js"))
-  end
-
-  it "should serve static files from src dir under /" do
-    get "/example.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "application/javascript"
-    last_response.body.should == File.read(File.join(@root, "fixture/src/example.js"))
-  end
-
-  it "should serve Jasmine static files under /__JASMINE_ROOT__/" do
-    get "/__JASMINE_ROOT__/jasmine.css"
-    last_response.status.should == 200
-    last_response.content_type.should == "text/css"
-    last_response.body.should == File.read(File.join(Jasmine::Core.path, "jasmine.css"))
-  end
-
-  it "should serve focused suites when prefixing spec files with /__suite__/" do
-    pending "Temporarily removing this feature (maybe permanent)"
-    Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
-    get "/__suite__/file2.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "text/html"
-    last_response.body.should include("\"/__spec__/file2.js")
-  end
-
-  it "should redirect /run.html to /" do
-    get "/run.html"
-    last_response.status.should == 302
-    last_response.location.should == "/"
-  end
-
-  it "should 404 non-existent files" do
-    get "/some-non-existent-file"
-    last_response.should be_not_found
-  end
-
-  describe "/ page" do
-    it "should load each js file in order" do
-      get "/"
-      last_response.status.should == 200
-      last_response.body.should include("path/file1.js")
-      last_response.body.should include("path/file2.js")
-    end
+#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
 
-    it "should return an empty 200 for HEAD requests to /" do
-      head "/"
-      last_response.status.should == 200
-      last_response.headers['Content-Type'].should == 'text/html'
-      last_response.body.should == ''
+      Jasmine::Application.app(config, builder).should == builder
     end
-
-    it "should tell the browser not to cache any assets" do
-      head "/"
-      ['Pragma'].each do |key|
-        last_response.headers[key].should == 'no-cache'
-      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