jasmine 1.3.0 → 1.3.1

data/Rakefile

@@ -29,10 +29,19 @@ task :default => :spec
 
 namespace :jasmine do
   require "jasmine-core"
-  require './spec/jasmine_self_test_config'
   task :server do
     port = ENV['JASMINE_PORT'] || 8888
-    JasmineSelfTestConfig.new.start_server(port)
+    Jasmine.configure do |config|
+      root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+      config.src_dir = File.join(root, 'src')
+      config.spec_dir = Jasmine::Core.path
+      config.spec_files = lambda { (Jasmine::Core.html_spec_files + Jasmine::Core.core_spec_files).map {|f| File.join(config.spec_dir, f) } }
+    end
+
+    config = Jasmine.config
+
+    server = Jasmine::Server.new(8888, Jasmine::Application.app(config))
+    server.start
 
     puts "your tests are here:"
     puts "  http://localhost:#{port}/"

data/generators/jasmine/templates/spec/javascripts/support/jasmine-rails.yml

@@ -43,7 +43,7 @@ stylesheets:
 #   - helpers/**/*.js
 #
 helpers:
-  - helpers/**/*.js
+  - 'helpers/**/*.js'
 
 # spec_files
 #
@@ -53,7 +53,7 @@ helpers:
 # EXAMPLE:
 #
 # spec_files:
-#   - **/*[sS]pec.js
+#   - '**/*[sS]pec.js'
 #
 spec_files:
   - '**/*[sS]pec.js'

data/generators/jasmine/templates/spec/javascripts/support/jasmine.yml

@@ -37,7 +37,7 @@ stylesheets:
 #   - helpers/**/*.js
 #
 helpers:
-
+  - 'helpers/**/*.js'
 # spec_files
 #
 #  Return an array of filepaths relative to spec_dir to include.
@@ -49,6 +49,7 @@ helpers:
 #   - **/*[sS]pec.js
 #
 spec_files:
+  - '**/*[sS]pec.js'
 
 # src_dir
 #

data/jasmine.gemspec

@@ -67,7 +67,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'json_pure'
   s.add_development_dependency 'nokogiri'
 
-  s.add_dependency 'jasmine-core', ">= 1.3.0"
+  s.add_dependency 'jasmine-core', "~> 1.3.1"
   s.add_dependency 'rack', '~> 1.0'
   s.add_dependency 'rspec', '>= 1.3.1'
   s.add_dependency 'selenium-webdriver', '>= 0.1.3'

data/lib/jasmine.rb

@@ -1,6 +1,7 @@
 jasmine_files = ['base',
                  'dependencies',
-                 'runner_config',
+                 'core_configuration',
+                 'configuration',
                  'config',
                  'application',
                  'server',
@@ -8,15 +9,22 @@ jasmine_files = ['base',
                  'rspec_formatter',
                  'command_line_tool',
                  'page',
+                 'path_mapper',
+                 'asset_pipeline_utility',
                  'asset_pipeline_mapper',
-                 'sprockets_mapper',
+                 'asset_expander',
                  'results_processor',
                  'results',
+                 'path_expander',
+                 'yaml_config_parser',
                  File.join('runners', 'http')]
 
 jasmine_files.each do |file|
   require File.join('jasmine', file)
 end
+# jasmine_rack_files.each do |file|
+  # require File.join('rack', 'jasmine', file)
+# end
 
 require File.join('jasmine', "railtie") if Jasmine::Dependencies.rails3?
 

data/lib/jasmine/application.rb

@@ -3,46 +3,19 @@ require 'rack/utils'
 require 'jasmine-core'
 require 'rack/jasmine/runner'
 require 'rack/jasmine/focused_suite'
-require 'rack/jasmine/redirect'
 require 'rack/jasmine/cache_control'
 require 'ostruct'
 
 module Jasmine
   class Application
-    def self.app(config = Jasmine::RunnerConfig.new)
-      page = Jasmine::Page.new(config)
-      if Jasmine::Dependencies.rails_3_asset_pipeline?
-        config.src_mapper = Jasmine::AssetPipelineMapper.new
+    def self.app(config, builder = Rack::Builder.new)
+      config.rack_apps.each do |(app, config_block)|
+        builder.use(app, &config_block)
       end
-      Rack::Builder.app do
-        use Rack::Head
-        use Rack::Jasmine::CacheControl
-        if Jasmine::Dependencies.rails_3_asset_pipeline?
-          map('/assets') do
-            #load the Sprockets asset helpers
-            Rails.application.assets.context_class.instance_eval do
-              include ::Sprockets::Helpers::IsolatedHelper
-              include ::Sprockets::Helpers::RailsHelper
-            end
-            run Rails.application.assets
-          end
-        end
-
-        map('/run.html')         { run Rack::Jasmine::Redirect.new('/') }
-        map('/__suite__')        { run Rack::Jasmine::FocusedSuite.new(config) }
-
-        #TODO: These path mappings should come from the config.
-        map('/__JASMINE_ROOT__') { run Rack::File.new(Jasmine::Core.path) }
-        map(config.spec_path)    { run Rack::File.new(config.spec_dir) }
-        map(config.root_path)    { run Rack::File.new(config.project_root) }
-
-        map('/') do
-          run Rack::Cascade.new([
-            Rack::URLMap.new('/' => Rack::File.new(config.src_dir)),
-            Rack::Jasmine::Runner.new(page)
-          ])
-        end
+      config.rack_path_map.each do |path, handler|
+        builder.map(path) { run handler.call }
       end
+      builder
     end
   end
 end

data/lib/jasmine/asset_expander.rb

@@ -0,0 +1,19 @@
+module Jasmine
+  class AssetExpander
+    def initialize(bundled_asset_factory, asset_path_for)
+      @bundled_asset_factory = bundled_asset_factory
+      @asset_path_for = asset_path_for
+    end
+
+    def expand(src_dir, src_path)
+      pathname = src_path.gsub(/^\/?assets\//, '').gsub(/\.js$/, '')
+      bundled_asset = @bundled_asset_factory.call(pathname, 'js')
+      return nil unless bundled_asset
+
+      base_asset = "#{bundled_asset.pathname.to_s.gsub(/#{src_dir}/, '')}?body=true"
+      bundled_asset.to_a.inject([base_asset]) do |assets, asset|
+        assets << "/#{@asset_path_for.call(asset).gsub(/^\//, '')}?body=true"
+      end.flatten
+    end
+  end
+end

data/lib/jasmine/asset_pipeline_mapper.rb

@@ -1,19 +1,16 @@
-class Jasmine::AssetPipelineMapper
+module Jasmine
+  class AssetPipelineMapper
 
-  def self.context
-    context = ::Rails.application.assets.context_class
-    context.extend(::Sprockets::Helpers::IsolatedHelper)
-    context.extend(::Sprockets::Helpers::RailsHelper)
-  end
+    def initialize(config, asset_expander)
+      @config = config
+      @asset_expander = asset_expander
+    end
 
-  def initialize(context = Jasmine::AssetPipelineMapper.context)
-    @context = context
-  end
+    def map_src_paths(src_paths)
+      src_paths.map do |src_path|
+        @asset_expander.call(@config.src_dir, src_path) || src_path
+      end.flatten.uniq
+    end
 
-  def files(src_files)
-    src_files.map do |src_file|
-    filename = src_file.gsub(/^assets\//, '').gsub(/\.js$/, '')
-    @context.asset_paths.asset_for(filename, 'js').to_a.map { |p| @context.asset_path(p).gsub(/^\//, '') + "?body=true" }
-    end.flatten.uniq
   end
 end

data/lib/jasmine/asset_pipeline_utility.rb

@@ -0,0 +1,19 @@
+module Jasmine
+  class AssetPipelineUtility
+    def self.bundled_asset_factory(pathname, ext)
+      context.asset_paths.asset_for(pathname, 'js')
+    end
+
+    def self.asset_path_for(filepath)
+      context.asset_path(filepath)
+    end
+
+    def self.context
+      return @context if @context
+      @context = ::Rails.application.assets.context_class
+      @context.extend(::Sprockets::Helpers::IsolatedHelper)
+      @context.extend(::Sprockets::Helpers::RailsHelper)
+    end
+
+  end
+end

data/lib/jasmine/base.rb

@@ -47,4 +47,8 @@ module Jasmine
     File.read(File.join(File.dirname(__FILE__), "run.html.erb"))
   end
 
+  def self.root(*paths)
+    File.expand_path(File.join(File.dirname(__FILE__), *paths))
+  end
+
 end

data/lib/jasmine/config.rb

@@ -1,122 +1,85 @@
 module Jasmine
-  class Config
-    attr_accessor :src_mapper
-
-    require 'yaml'
-    require 'erb'
-    require 'json'
-
-    def match_files(dir, patterns)
-      dir = File.expand_path(dir)
-      negative, positive = patterns.partition {|pattern| /^!/ =~ pattern}
-      chosen, negated = [positive, negative].collect do |patterns|
-        patterns.collect do |pattern|
-          matches = Dir.glob(File.join(dir, pattern.gsub(/^!/,'')))
-          matches.empty? && !(pattern =~ /\*|^\!/) ? pattern : matches.collect {|f| f.sub("#{dir}/", "")}.sort
-        end.flatten.uniq
-      end
-      chosen - negated
-    end
-
-    def simple_config
-      config = File.exist?(simple_config_file) ? YAML::load(ERB.new(File.read(simple_config_file)).result(binding)) : false
-      config || {}
-    end
-
-
-    def spec_path
-      "/__spec__"
-    end
-
-    def root_path
-      "/__root__"
-    end
-
-    def js_files(spec_filter = nil)
-      spec_files_to_include = spec_filter.nil? ? spec_files : match_files(spec_dir, [spec_filter])
-      src_files.collect {|f| "/" + f } + helpers.collect {|f| File.join(spec_path, f) } + spec_files_to_include.collect {|f| File.join(spec_path, f) }
-    end
-
-    def user_stylesheets
-      stylesheets.collect {|f| "/" + f }
-    end
-
-    def spec_files_full_paths
-      spec_files.collect {|spec_file| File.join(spec_dir, spec_file) }
-    end
-
-    def project_root
-      Dir.pwd
-    end
-
-    def simple_config_file
-      File.join(project_root, 'spec/javascripts/support/jasmine.yml')
-    end
-
-    def src_dir
-      if simple_config['src_dir']
-        File.join(project_root, simple_config['src_dir'])
-      else
-        project_root
-      end
-    end
+  require 'erb'
+  def self.configure(&block)
+    block.call(self.config)
+  end
 
-    def spec_dir
-      if simple_config['spec_dir']
-        File.join(project_root, simple_config['spec_dir'])
-      else
-        File.join(project_root, 'spec/javascripts')
-      end
+  def self.initialize_config
+    return if @config
+    @config = Jasmine::Configuration.new
+    core_config = Jasmine::CoreConfiguration.new
+
+    @config.add_path_mapper(Jasmine::PathMapper.method(:new))
+
+    @config.jasmine_path = jasmine_path = "/__jasmine__"
+    @config.src_path = src_path = "/"
+    @config.spec_path = spec_path = "/__spec__"
+    @config.boot_path = boot_path = "/__boot__"
+
+    @config.jasmine_dir = core_config.path
+    @config.boot_dir = core_config.boot_path
+    @config.boot_files = lambda { core_config.boot_files }
+    @config.jasmine_files = lambda { core_config.js_files }
+    @config.jasmine_css_files = lambda { core_config.css_files }
+
+    @config.add_rack_path(jasmine_path, lambda { Rack::File.new(config.jasmine_dir) })
+    @config.add_rack_path(boot_path, lambda { Rack::File.new(config.boot_dir) })
+    @config.add_rack_path(spec_path, lambda { Rack::File.new(config.spec_dir) })
+    @config.add_rack_path(src_path, lambda {
+      Rack::Cascade.new([
+        Rack::URLMap.new('/' => Rack::File.new(config.src_dir)),
+        Rack::Jasmine::Runner.new(Jasmine::Page.new(config))
+      ])
+    })
+
+    @config.add_rack_app(Rack::Head)
+    @config.add_rack_app(Rack::Jasmine::CacheControl)
+
+    if Jasmine::Dependencies.rails_3_asset_pipeline?
+      @config.add_path_mapper(lambda { |config|
+        asset_expander = Jasmine::AssetExpander.new(
+          Jasmine::AssetPipelineUtility.method(:bundled_asset_factory),
+          Jasmine::AssetPipelineUtility.method(:asset_path_for)
+        )
+        Jasmine::AssetPipelineMapper.new(config, asset_expander.method(:expand))
+      })
+      @config.add_rack_path('/assets', lambda {
+        # In order to have asset helpers like asset_path and image_path, we need to require 'action_view/base'.  This
+        # triggers run_load_hooks on action_view which, in turn, causes sprockets/railtie to load the Sprockets asset
+        # helpers.  Alternatively, you can include the helpers yourself without loading action_view/base:
+        Rails.application.assets.context_class.instance_eval do
+          include ::Sprockets::Helpers::IsolatedHelper
+          include ::Sprockets::Helpers::RailsHelper
+        end
+        Rails.application.assets
+      })
     end
 
-    def helpers
-      if simple_config['helpers']
-        match_files(spec_dir, simple_config['helpers'])
-      else
-        match_files(spec_dir, ["helpers/**/*.js"])
-      end
-    end
-
-    def src_files
-      return [] unless simple_config['src_files']
+  end
 
-      if self.src_mapper
-        self.src_mapper.files(simple_config['src_files'])
-      else
-        match_files(src_dir, simple_config['src_files'])
-      end
-    end
+  def self.config
+    initialize_config
+    @config
+  end
 
-    def spec_files
-      if simple_config['spec_files']
-        match_files(spec_dir, simple_config['spec_files'])
-      else
-        match_files(spec_dir, ["**/*[sS]pec.js"])
+  def self.load_configuration_from_yaml(path = nil)
+    path ||= File.join(Dir.pwd, 'spec', 'javascripts', 'support', 'jasmine.yml')
+    if File.exist?(path)
+      yaml_loader = lambda do |filepath|
+        YAML::load(ERB.new(File.read(filepath)).result(binding)) if File.exist?(filepath)
       end
-    end
-
-    def stylesheets
-      if simple_config['stylesheets']
-        match_files(src_dir, simple_config['stylesheets'])
-      else
-        []
+      yaml_config = Jasmine::YamlConfigParser.new(path, Dir.pwd, Jasmine::PathExpander.method(:expand), yaml_loader)
+      Jasmine.configure do |config|
+        config.jasmine_dir = yaml_config.jasmine_dir if yaml_config.jasmine_dir
+        config.jasmine_files = lambda { yaml_config.jasmine_files } if yaml_config.jasmine_files.any?
+        config.jasmine_css_files = lambda { yaml_config.jasmine_css_files } if yaml_config.jasmine_css_files.any?
+        config.src_files = lambda { yaml_config.src_files }
+        config.spec_files = lambda { yaml_config.helpers + yaml_config.spec_files }
+        config.css_files = lambda { yaml_config.css_files }
+        config.src_dir = yaml_config.src_dir
+        config.spec_dir = yaml_config.spec_dir
       end
     end
-
-    def jasmine_host
-      ENV["JASMINE_HOST"] || 'http://localhost'
-    end
-
-    def port
-      @port ||= ENV["JASMINE_PORT"] || Jasmine.find_unused_port
-    end
-
-    def jasmine_stylesheets
-      ::Jasmine::Core.css_files.map {|f| "/__JASMINE_ROOT__/#{f}"}
-    end
-
-    def jasmine_javascripts
-      ::Jasmine::Core.js_files.map {|f| "/__JASMINE_ROOT__/#{f}" }
-    end
   end
+
 end

data/lib/jasmine/configuration.rb

@@ -0,0 +1,83 @@
+module Jasmine
+  class Configuration
+    attr_writer :jasmine_css_files, :css_files
+    attr_writer :jasmine_files, :boot_files, :src_files, :spec_files
+    attr_accessor :jasmine_path, :spec_path, :boot_path, :src_path
+    attr_accessor :jasmine_dir, :spec_dir, :boot_dir, :src_dir
+    #TODO: these are largely client concerns, move them.
+    attr_accessor :port, :browser, :host, :result_batch_size
+
+    def initialize()
+      @rack_paths = {}
+      @apps = []
+      @path_mappers = []
+      @jasmine_css_files = lambda { [] }
+      @css_files = lambda { [] }
+      @jasmine_files = lambda { [] }
+      @boot_files = lambda { [] }
+      @src_files = lambda { [] }
+      @spec_files = lambda { [] }
+    end
+
+    def css_files
+      map(@jasmine_css_files, :jasmine) +
+        map(@css_files, :src)
+    end
+
+    def js_files
+      map(@jasmine_files, :jasmine) +
+        map(@src_files, :src) +
+        map(@spec_files, :spec) +
+        map(@boot_files, :boot)
+    end
+
+    def rack_path_map
+      {}.merge(@rack_paths)
+    end
+
+    def add_rack_path(path, rack_app_lambda)
+      @rack_paths[path] = rack_app_lambda
+    end
+
+    def rack_apps
+      [] + @apps
+    end
+
+    def add_rack_app(app, &block)
+      @apps << [app, block]
+    end
+
+    def add_path_mapper(mapper)
+      @path_mappers << mapper.call(self)
+    end
+
+    def port
+      @port ||= Jasmine.find_unused_port
+    end
+
+    def browser
+      @browser || 'firefox'
+    end
+
+    def host
+      @host || 'http://localhost'
+    end
+
+    def result_batch_size
+      @result_batch_size || 50
+    end
+
+    private
+
+    def map(paths, type)
+      @path_mappers.inject(paths.call)  do |paths, mapper|
+        if mapper.respond_to?("map_#{type}_paths")
+          mapper.send("map_#{type}_paths", paths)
+        else
+          paths
+        end
+      end
+    end
+
+  end
+end