jasmine 1.3.2 → 2.0.0.rc2

data/lib/jasmine/asset_pipeline_utility.rb

@@ -1,19 +0,0 @@
-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/javascripts/boot.js

@@ -1,28 +0,0 @@
-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/rspec_formatter.rb

@@ -1,92 +0,0 @@
-require 'enumerator'
-
-module Jasmine
-  class RspecFormatter
-
-    def format_results(results)
-      @results = results
-      declare_suites(@results.suites)
-    end
-
-    def declare_suites(suites)
-      suites.each do |suite|
-        #empty block for rspec 1
-        group = example_group(suite["name"]) {}
-        process_children(group, suite["children"])
-      end
-    end
-
-    def process_children(parent, children)
-      children.each do |suite_or_spec|
-        type = suite_or_spec["type"]
-        if type == "suite"
-          process_children(parent.describe(suite_or_spec["name"]), suite_or_spec["children"])
-        elsif type == "spec"
-          declare_spec(parent, suite_or_spec)
-        else
-          raise "unknown type #{type} for #{suite_or_spec.inspect}"
-        end
-      end
-    end
-
-    def declare_spec(parent, spec)
-      me = self
-      example_name = spec["name"]
-      backtrace = @results.example_location_for(parent.description + " " + example_name)
-      if Jasmine::Dependencies.rspec2?
-        parent.it example_name, {} do
-          me.report_spec(spec["id"])
-        end
-      else
-        parent.it example_name, {}, backtrace do
-          me.report_spec(spec["id"])
-        end
-      end
-    end
-
-    def report_spec(spec_id)
-      spec_results = results_for(spec_id)
-      out = ""
-      messages = spec_results['messages'].each do |message|
-        case
-        when message["type"] == "log"
-          puts message["text"]
-          puts "\n"
-        else
-          unless message["message"] =~ /^Passed.$/
-            STDERR << message["message"]
-            STDERR << "\n"
-
-            out << message["message"]
-            out << "\n"
-          end
-
-          if !message["passed"] && message["trace"]["stack"]
-            stack_trace = message["trace"]["stack"].gsub(/<br \/>/, "\n").gsub(/<\/?b>/, " ")
-            STDERR << stack_trace.gsub(/\(.*\)@http:\/\/localhost:[0-9]+\/specs\//, "/spec/")
-            STDERR << "\n"
-          end
-        end
-
-      end
-      fail out unless spec_results['result'] == 'passed'
-      puts out unless out.empty?
-    end
-
-    private
-
-    def example_group(*args, &block)
-      if Jasmine::Dependencies.rspec2?
-        RSpec::Core::ExampleGroup.describe(*args, &block).register
-      else
-        Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
-      end
-    end
-
-    def results_for(spec_id)
-      @results.for_spec_id(spec_id.to_s)
-    end
-
-
-  end
-end

data/spec/dependencies_spec.rb

@@ -1,315 +0,0 @@
-require 'spec_helper'
-
-#rspec 1 fails to stub respond_to
-if Jasmine::Dependencies.rspec2?
-  describe Jasmine::Dependencies do
-    module Rails
-    end
-
-    context "with ruby_gems > 1.8" do
-      before do
-        Gem::Specification.should_receive(:respond_to?).with(:find_by_name).and_return(true)
-      end
-
-      describe ".rspec2?" do
-        subject { Jasmine::Dependencies.rspec2? }
-        context "when rspec 2 is present" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rspec", ">= 2.0").and_return(true)
-          end
-          it { should be_true }
-        end
-        context "when rspec 2 is not present" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rspec", ">= 2.0").and_raise(Gem::LoadError)
-          end
-          it { should be_false }
-        end
-      end
-
-      describe ".rails2?" do
-        subject { Jasmine::Dependencies.rails2? }
-        context "when rails 2 is present and running" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", "~> 2.3").and_return(true)
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-          let(:running_rails_version) { "2.3.11" }
-          it { should be_true }
-        end
-        context "when rails 2 is present but not running" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", "~> 2.3").and_raise(Gem::LoadError)
-          end
-          it { should be_false }
-        end
-        context "when rails 2 is not present" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", "~> 2.3").and_raise(Gem::LoadError)
-          end
-          it { should be_false }
-        end
-      end
-
-      describe ".legacy_rails?" do
-        subject { Jasmine::Dependencies.legacy_rails? }
-        context "when rails < 2.3.11 is present and running" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", "< 2.3.11").and_return(true)
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-          let(:running_rails_version) { "2.3.8" }
-          it { should be_true }
-        end
-        context "when rails < 2.3.11 is present but not running" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", "< 2.3.11").and_return(true)
-          end
-          it { should be_false }
-        end
-        context "when rails < 2.3.11 is not present" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", "< 2.3.11").and_raise(Gem::LoadError)
-          end
-          it { should be_false }
-        end
-      end
-
-      describe ".rails3?" do
-        subject { Jasmine::Dependencies.rails3? }
-        context "when rails 3 is present and running" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-          let(:running_rails_version) { "3.2" }
-          it { should be_true }
-        end
-        context "when rails 3 is present but not running" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-          end
-          it { should be_false }
-        end
-        context "when rails 3 is not present" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_raise(Gem::LoadError)
-          end
-          it { should be_false }
-        end
-      end
-
-      describe ".rails_3_asset_pipeline?" do
-        subject { Jasmine::Dependencies.rails_3_asset_pipeline? }
-        let(:application) { double(:application) }
-        let(:running_rails_version) { "3.2" }
-        before do
-          Rails.stub(:respond_to?).with(:application).and_return(respond_to_application)
-          Rails.stub(:application).and_return(application)
-          Rails.stub(:respond_to?).with(:version).and_return(true)
-          Rails.stub(:version).and_return(running_rails_version)
-        end
-        context "when rails 3 is present and the application pipeline is in use" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-            application.stub(:assets).and_return(rails_application_assets)
-          end
-          let(:rails3_present) { true }
-          let(:respond_to_application) { true }
-          let(:rails_application_assets) { true }
-          it { should be_true }
-        end
-        context "when rails 3 is present and the application pipeline is not in use" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-            application.stub(:assets).and_return(rails_application_assets)
-          end
-          let(:rails3_present) { true }
-          let(:respond_to_application) { true }
-          let(:rails_application_assets) { false }
-          it { should be_false }
-        end
-        context "when rails 3 is present but not loaded" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-            application.stub(:assets).and_return(rails_application_assets)
-          end
-          let(:rails3_present) { true }
-          let(:respond_to_application) { false }
-          let(:rails_application_assets) { false }
-          it { should be_false }
-        end
-        context "when rails 3 is present but doesn't respond to assets" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-          end
-          let(:rails3_present) { true }
-          let(:respond_to_application) { true }
-          it { should be_false }
-        end
-        context "when rails 3 is not present" do
-          before do
-            Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_raise(Gem::LoadError)
-          end
-          let(:rails3_present) { false }
-          let(:respond_to_application) { false }
-          let(:rails_application_assets) { false }
-          it { should be_false }
-        end
-      end
-    end
-
-    context "with ruby_gems < 1.8" do
-      before do
-        Gem::Specification.should_receive(:respond_to?).with(:find_by_name).and_return(false)
-      end
-
-      describe ".rspec2?" do
-        subject { Jasmine::Dependencies.rspec2? }
-        before do
-          Gem.should_receive(:available?).with("rspec", ">= 2.0").and_return(rspec2_present)
-        end
-        context "when rspec 2 is present" do
-          let(:rspec2_present) { true }
-          it { should be_true }
-        end
-        context "when rspec 2 is not present" do
-          let(:rspec2_present) { false }
-          it { should be_false }
-        end
-      end
-
-      describe ".rails2?" do
-        subject { Jasmine::Dependencies.rails2? }
-        before do
-          Gem.should_receive(:available?).with("rails", "~> 2.3").and_return(rails2_present)
-        end
-        context "when rails 2 is present and running" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-
-          let(:running_rails_version) { "2.3" }
-          let(:rails2_present) { true }
-          it { should be_true }
-        end
-        context "when rails 2 is present but not running" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-
-          let(:running_rails_version) { "3.2" }
-          let(:rails2_present) { true }
-          it { should be_false }
-        end
-        context "when rails 2 is not present" do
-          let(:rails2_present) { false }
-          it { should be_false }
-        end
-      end
-
-      describe ".legacy_rails?" do
-        subject { Jasmine::Dependencies.legacy_rails? }
-        before do
-          Gem.should_receive(:available?).with("rails", "< 2.3.11").and_return(legacy_rails_present)
-        end
-        context "when rails < 2.3.11 is present and running" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-          let(:running_rails_version) { "2.3.8" }
-          let(:legacy_rails_present) { true }
-          it { should be_true }
-        end
-
-        context "when rails < 2.3.11 is present but not running" do
-          let(:legacy_rails_present) { true }
-          it { should be_false }
-        end
-
-        context "when rails < 2.3.11 is not present" do
-          let(:legacy_rails_present) { false }
-          it { should be_false }
-        end
-      end
-
-      describe ".rails3?" do
-        subject { Jasmine::Dependencies.rails3? }
-        before do
-          Gem.should_receive(:available?).with("rails", ">= 3.0").and_return(rails3_present)
-        end
-        context "when rails 3 is present" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-          let(:running_rails_version) { "3.2" }
-          let(:rails3_present) { true }
-          it { should be_true }
-        end
-        context "when rails 3 is not present" do
-          let(:rails3_present) { false }
-          it { should be_false }
-        end
-      end
-
-      describe ".rails_3_asset_pipeline?" do
-        subject { Jasmine::Dependencies.rails_3_asset_pipeline? }
-        let(:application) { double(:application, :assets => rails_application_assets)}
-        before do
-          Gem.should_receive(:available?).with("rails", ">= 3.0").and_return(rails3_present)
-          Rails.stub(:respond_to?).with(:application).and_return(respond_to_application)
-          Rails.stub(:respond_to?).with(:version).and_return(true)
-          Rails.stub(:application).and_return(application)
-        end
-
-        context "when rails 3 is present, running, and the application pipeline is in use" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-          let(:rails3_present) { true }
-          let(:running_rails_version) { "3.2" }
-          let(:respond_to_application) { true }
-          let(:rails_application_assets) { true }
-          it { should be_true }
-        end
-        context "when rails 3 is present, running, and the application pipeline is not in use" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(true)
-            Rails.stub(:version).and_return(running_rails_version)
-          end
-          let(:rails3_present) { true }
-          let(:running_rails_version) { "3.2" }
-          let(:respond_to_application) { true }
-          let(:rails_application_assets) { false }
-          it { should be_false }
-        end
-        context "when rails 3 is present but not loaded" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(false)
-          end
-          let(:rails3_present) { true }
-          let(:respond_to_application) { false }
-          let(:rails_application_assets) { false }
-          it { should be_false }
-        end
-        context "when rails 3 is not present" do
-          before do
-            Rails.stub(:respond_to?).with(:version).and_return(false)
-          end
-          let(:rails3_present) { false }
-          let(:respond_to_application) { false }
-          let(:rails_application_assets) { false }
-          it { should be_false }
-        end
-      end
-    end
-  end
-end