rally-jasmine 1.2.0

data/lib/generators/jasmine/examples/templates/app/assets/javascripts/jasmine_examples/Player.js

@@ -0,0 +1,22 @@
+function Player() {
+}
+Player.prototype.play = function(song) {
+  this.currentlyPlayingSong = song;
+  this.isPlaying = true;
+};
+
+Player.prototype.pause = function() {
+  this.isPlaying = false;
+};
+
+Player.prototype.resume = function() {
+  if (this.isPlaying) {
+    throw new Error("song is already playing");
+  }
+
+  this.isPlaying = true;
+};
+
+Player.prototype.makeFavorite = function() {
+  this.currentlyPlayingSong.persistFavoriteStatus(true);
+};

data/lib/generators/jasmine/examples/templates/app/assets/javascripts/jasmine_examples/Song.js

@@ -0,0 +1,7 @@
+function Song() {
+}
+
+Song.prototype.persistFavoriteStatus = function(value) {
+  // something complicated
+  throw new Error("not yet implemented");
+};

data/lib/generators/jasmine/examples/templates/spec/javascripts/helpers/SpecHelper.js

@@ -0,0 +1,9 @@
+beforeEach(function() {
+  this.addMatchers({
+    toBePlaying: function(expectedSong) {
+      var player = this.actual;
+      return player.currentlyPlayingSong === expectedSong
+          && player.isPlaying;
+    }
+  })
+});

data/lib/generators/jasmine/examples/templates/spec/javascripts/jasmine_examples/PlayerSpec.js

@@ -0,0 +1,58 @@
+describe("Player", function() {
+  var player;
+  var song;
+
+  beforeEach(function() {
+    player = new Player();
+    song = new Song();
+  });
+
+  it("should be able to play a Song", function() {
+    player.play(song);
+    expect(player.currentlyPlayingSong).toEqual(song);
+
+    //demonstrates use of custom matcher
+    expect(player).toBePlaying(song);
+  });
+
+  describe("when song has been paused", function() {
+    beforeEach(function() {
+      player.play(song);
+      player.pause();
+    });
+
+    it("should indicate that the song is currently paused", function() {
+      expect(player.isPlaying).toBeFalsy();
+
+      // demonstrates use of 'not' with a custom matcher
+      expect(player).not.toBePlaying(song);
+    });
+
+    it("should be possible to resume", function() {
+      player.resume();
+      expect(player.isPlaying).toBeTruthy();
+      expect(player.currentlyPlayingSong).toEqual(song);
+    });
+  });
+
+  // demonstrates use of spies to intercept and test method calls
+  it("tells the current song if the user has made it a favorite", function() {
+    spyOn(song, 'persistFavoriteStatus');
+
+    player.play(song);
+    player.makeFavorite();
+
+    expect(song.persistFavoriteStatus).toHaveBeenCalledWith(true);
+  });
+
+  //demonstrates use of expected exceptions
+  describe("#resume", function() {
+    it("should throw an exception if song is already playing", function() {
+      player.play(song);
+
+      expect(function() {
+        player.resume();
+      }).toThrow("song is already playing");
+    });
+  });
+});

data/lib/generators/jasmine/install/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Install jasmine
+
+Example:
+    rails generate jasmine:install
+
+    This will create:
+        spec/javascripts/support/jasmine.yml
+        spec/javascripts/support/jasmine_config.rb
+        spec/javascripts/support/jasmine_runner.rb
+        spec/javascripts/helpers/.gitkeep

data/lib/generators/jasmine/install/install_generator.rb

@@ -0,0 +1,18 @@
+module Jasmine
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+
+      def self.source_root
+        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      end
+
+      def copy_spec_files
+        directory 'spec'
+      end
+
+      def app_name
+        Rails.application.class.name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+  - assets/application.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+  - stylesheets/**/*.css
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+  - helpers/**/*.js
+
+# spec_files
+#
+# Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - **/*[sS]pec.js
+#
+spec_files:
+  - '**/*[sS]pec.js'
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir:
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir: spec/javascripts

data/lib/jasmine/application.rb

@@ -0,0 +1,43 @@
+require 'rack'
+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
+      end
+      Rack::Builder.app do
+        use Rack::Head
+        use Rack::Jasmine::CacheControl
+        if Jasmine::Dependencies.rails_3_asset_pipeline?
+          map('/assets') do
+            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
+      end
+    end
+  end
+end

data/lib/jasmine/asset_pipeline_mapper.rb

@@ -0,0 +1,19 @@
+class Jasmine::AssetPipelineMapper
+
+  def self.context
+    context = ::Rails.application.assets.context_class
+    context.extend(::Sprockets::Helpers::IsolatedHelper)
+    context.extend(::Sprockets::Helpers::RailsHelper)
+  end
+
+  def initialize(context = Jasmine::AssetPipelineMapper.context)
+    @context = context
+  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/base.rb

@@ -0,0 +1,50 @@
+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
+
+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,121 @@
+module Jasmine
+  class Config
+    attr_accessor :src_mapper
+
+    require 'yaml'
+    require 'erb'
+
+    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
+
+    def spec_dir
+      if simple_config['spec_dir']
+        File.join(project_root, simple_config['spec_dir'])
+      else
+        File.join(project_root, 'spec/javascripts')
+      end
+    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']
+
+      if self.src_mapper
+        self.src_mapper.files(simple_config['src_files'])
+      else
+        match_files(src_dir, simple_config['src_files'])
+      end
+    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"])
+      end
+    end
+
+    def stylesheets
+      if simple_config['stylesheets']
+        match_files(src_dir, simple_config['stylesheets'])
+      else
+        []
+      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/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?
+        !Rack.constants.include?(: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

data/lib/jasmine/firebug/firebug-license.txt

@@ -0,0 +1,30 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2007, Parakey Inc.
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of Parakey Inc. nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of Parakey Inc.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/jasmine/firebug/firebug.rb

@@ -0,0 +1,30 @@
+require 'selenium/webdriver'
+
+class Selenium::WebDriver::Firefox::Profile
+  def self.firebug_version
+    @firebug_version ||= '1.6.2'
+  end
+
+  def self.firebug_version=(version)
+    @firebug_version = version
+  end
+
+  def enable_firebug(version = nil)
+    version ||= Selenium::WebDriver::Firefox::Profile.firebug_version
+    add_extension(File.expand_path("../firebug-#{version}.xpi", __FILE__))
+
+    # Prevent "Welcome!" tab
+    self["extensions.firebug.currentVersion"] = "999"
+
+    # Enable for all sites.
+    self["extensions.firebug.allPagesActivation"] = "on"
+
+    # Enable all features.
+    ['console', 'net', 'script'].each do |feature|
+      self["extensions.firebug.#{feature}.enableSites"] = true
+    end
+
+    # Open by default.
+    self["extensions.firebug.previousPlacement"] = 1
+  end
+end

data/lib/jasmine/page.rb

@@ -0,0 +1,11 @@
+module Jasmine
+  class Page
+    def initialize(context)
+      @context = context
+    end
+
+    def render
+      ERB.new(::Jasmine.runner_template).result(@context.instance_eval { binding })
+    end
+  end
+end

data/lib/jasmine/railtie.rb

@@ -0,0 +1,21 @@
+require "rails/railtie"
+module Jasmine
+  class Railtie < Rails::Railtie
+
+    config.before_configuration do
+      old_jasmine_rakefile = ::Rails.root.join('lib', 'tasks', 'jasmine.rake')
+      if old_jasmine_rakefile.exist? && !ENV["USE_JASMINE_RAKE"]
+        puts %Q{
+            You no longer need to have jasmine.rake in your project, as it is now automatically loaded
+            from the Jasmine gem. To silence this warning, set "USE_JASMINE_RAKE=true" in your environment
+            or remove jasmine.rake.
+          }
+      end
+    end
+
+    rake_tasks do
+      load "jasmine/tasks/jasmine.rake"
+      load "jasmine/tasks/jasmine_rails3.rake"
+    end
+  end
+end