jasmine-multi_json 1.3.1.1

data/lib/jasmine.rb

@@ -0,0 +1,31 @@
+jasmine_files = ['base',
+                 'dependencies',
+                 'core_configuration',
+                 'configuration',
+                 'config',
+                 'application',
+                 'server',
+                 'selenium_driver',
+                 'rspec_formatter',
+                 'command_line_tool',
+                 'page',
+                 'path_mapper',
+                 'asset_pipeline_utility',
+                 'asset_pipeline_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

@@ -0,0 +1,21 @@
+require 'rack'
+require 'rack/utils'
+require 'jasmine-core'
+require 'rack/jasmine/runner'
+require 'rack/jasmine/focused_suite'
+require 'rack/jasmine/cache_control'
+require 'ostruct'
+
+module Jasmine
+  class Application
+    def self.app(config, builder = Rack::Builder.new)
+      config.rack_apps.each do |(app, config_block)|
+        builder.use(app, &config_block)
+      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

@@ -0,0 +1,16 @@
+module Jasmine
+  class AssetPipelineMapper
+
+    def initialize(config, asset_expander)
+      @config = config
+      @asset_expander = asset_expander
+    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
+
+  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

@@ -0,0 +1,54 @@
+require 'socket'
+require 'erb'
+
+module Jasmine
+  # 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 = 20)
+    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.runner_filepath
+    File.expand_path(File.join(File.dirname(__FILE__), "run_specs.rb"))
+  end
+
+  def self.runner_template
+    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/command_line_tool.rb

@@ -0,0 +1,70 @@
+module Jasmine
+  class CommandLineTool
+    def cwd
+      File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+    end
+
+    def expand(*paths)
+      File.expand_path(File.join(*paths))
+    end
+
+    def template_path(filepath)
+      expand(cwd, File.join("generators", "jasmine" ,"templates", filepath))
+    end
+
+    def dest_path(filepath)
+      expand(Dir.pwd, filepath)
+    end
+
+    def copy_unless_exists(relative_path, dest_path = nil)
+      unless File.exist?(dest_path(relative_path))
+        FileUtils.copy(template_path(relative_path), dest_path(dest_path || relative_path))
+      end
+    end
+
+    def process(argv)
+      if argv[0] == 'init'
+        require 'fileutils'
+
+        FileUtils.makedirs('public/javascripts')
+        FileUtils.makedirs('spec/javascripts')
+        FileUtils.makedirs('spec/javascripts/support')
+        FileUtils.makedirs('spec/javascripts/helpers')
+
+        copy_unless_exists('jasmine-example/src/Player.js', 'public/javascripts/Player.js')
+        copy_unless_exists('jasmine-example/src/Song.js', 'public/javascripts/Song.js')
+        copy_unless_exists('jasmine-example/spec/PlayerSpec.js', 'spec/javascripts/PlayerSpec.js')
+        copy_unless_exists('jasmine-example/spec/SpecHelper.js', 'spec/javascripts/helpers/SpecHelper.js')
+
+        rails_tasks_dir = dest_path('lib/tasks')
+        if File.exist?(rails_tasks_dir)
+          copy_unless_exists('lib/tasks/jasmine.rake')
+          copy_unless_exists('spec/javascripts/support/jasmine-rails.yml', 'spec/javascripts/support/jasmine.yml')
+        else
+          copy_unless_exists('spec/javascripts/support/jasmine.yml')
+          require 'rake'
+          write_mode = 'w'
+          if File.exist?(dest_path('Rakefile'))
+            load dest_path('Rakefile')
+            write_mode = 'a'
+          end
+
+          unless Rake::Task.task_defined?('jasmine')
+            File.open(dest_path('Rakefile'), write_mode) do |f|
+              f.write("\n" + File.read(template_path('lib/tasks/jasmine.rake')))
+            end
+          end
+        end
+        File.open(template_path('INSTALL'), 'r').each_line do |line|
+          puts line
+        end
+      elsif argv[0] == "license"
+        puts File.new(expand(cwd, "MIT.LICENSE")).read
+      else
+        puts "unknown command #{argv}"
+        puts "Usage: jasmine init"
+        puts "               license"
+      end
+    end
+  end
+end

data/lib/jasmine/config.rb

@@ -0,0 +1,85 @@
+module Jasmine
+  require 'erb'
+  def self.configure(&block)
+    block.call(self.config)
+  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
+
+  end
+
+  def self.config
+    initialize_config
+    @config
+  end
+
+  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
+      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
+  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

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/dependencies.rb

@@ -0,0 +1,59 @@
+module Jasmine
+  module Dependencies
+
+    class << self
+      def rspec2?
+        safe_gem_check("rspec", ">= 2.0")
+      end
+
+      def rails2?
+        safe_gem_check("rails", "~> 2.3") && running_rails2?
+      end
+
+      def legacy_rails?
+        safe_gem_check("rails", "< 2.3.11") && running_legacy_rails?
+      end
+
+      def rails3?
+        safe_gem_check("rails", ">= 3.0") && running_rails3?
+      end
+
+      def legacy_rack?
+        !defined?(Rack::Server)
+      end
+
+      def rails_3_asset_pipeline?
+        rails3? && Rails.respond_to?(:application) && Rails.application.respond_to?(:assets) && Rails.application.assets
+      end
+
+      private
+
+      def running_legacy_rails?
+        running_rails? && (Gem::Version.new(Rails.version) < Gem::Version.new("2.3.11"))
+      end
+
+      def running_rails2?
+        running_rails? && Rails.version.to_i == 2
+      end
+
+      def running_rails3?
+        running_rails? && Rails.version.to_i == 3
+      end
+
+      def running_rails?
+        defined?(Rails) && Rails.respond_to?(:version)
+      end
+
+      def safe_gem_check(gem_name, version_string)
+        if Gem::Specification.respond_to?(:find_by_name)
+          Gem::Specification.find_by_name(gem_name, version_string)
+        elsif Gem.respond_to?(:available?)
+          Gem.available?(gem_name, version_string)
+        end
+      rescue Gem::LoadError
+        false
+      end
+
+    end
+  end
+end