jasmine 2.6.0 → 2.7.0

data/spec/lib/jasmine/formatters/multi_spec.rb

@@ -8,20 +8,20 @@ describe Jasmine::Formatters::Multi do
 
     results1 = double(:results1)
 
-    formatter1.should_receive(:format).with(results1)
-    formatter2.should_receive(:format).with(results1)
+    expect(formatter1).to receive(:format).with(results1)
+    expect(formatter2).to receive(:format).with(results1)
     multi.format(results1)
 
     results2 = double(:results1)
 
-    formatter1.should_receive(:format).with(results2)
-    formatter2.should_receive(:format).with(results2)
+    expect(formatter1).to receive(:format).with(results2)
+    expect(formatter2).to receive(:format).with(results2)
     multi.format(results2)
 
     run_details = double(:run_details)
 
-    formatter1.should_receive(:done).with(run_details)
-    formatter2.should_receive(:done).with(run_details)
+    expect(formatter1).to receive(:done).with(run_details)
+    expect(formatter2).to receive(:done).with(run_details)
     multi.done(run_details)
   end
 end

data/spec/page_spec.rb

@@ -12,12 +12,12 @@ describe Jasmine::Page do
     let(:page) { Jasmine::Page.new(context) }
     it "should render javascript files in the correct order" do
       js_files = subject.css("script")
-      js_files.map { |file| file["src"] }.compact.should == ["file1.js", "file2.js"]
+      expect(js_files.map { |file| file["src"] }.compact).to eq ["file1.js", "file2.js"]
     end
 
     it "should render css files in the correct order" do
       css_files = subject.css("link[type='text/css']")
-      css_files.map { |file| file["href"] }.compact.should == ["file1.css", "file2.css"]
+      expect(css_files.map { |file| file["href"] }.compact).to eq ["file1.css", "file2.css"]
     end
   end
 end

data/spec/path_expander_spec.rb

@@ -19,7 +19,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src1.js'),
       File.join('some_base', 'src15.js'),
       File.join('some_base', 'src2.js')
@@ -44,7 +44,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src1.js'),
       File.join('some_base', 'src15.js'),
       File.join('some_base', 'src2.js')
@@ -69,7 +69,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src1.js'),
       File.join('some_base', 'src1zzz.js'),
       File.join('some_base', 'src0.js')
@@ -96,7 +96,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src15.js'),
       File.join('some_base', 'src2.js')
     ]
@@ -114,7 +114,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src2.js')
     ]
   end
@@ -131,7 +131,7 @@ describe Jasmine::PathExpander do
         dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
         'http://www.google.com'
     ]
   end

data/spec/path_mapper_spec.rb

@@ -4,35 +4,35 @@ describe Jasmine::PathMapper do
   it "correctly remaps src files" do
     config = double(:config, :src_dir => '/src_dir', :src_path => '/__src__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_src_paths(['/src_dir/foo']).should == ['/__src__/foo']
-    mapper.map_src_paths(['foo/bar']).should == ['/__src__/foo/bar']
+    expect(mapper.map_src_paths(['/src_dir/foo'])).to eq ['/__src__/foo']
+    expect(mapper.map_src_paths(['foo/bar'])).to eq ['/__src__/foo/bar']
   end
   it "correctly remaps spec files" do
     config = double(:config, :spec_dir => '/spec_dir', :spec_path => '/__spec__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_spec_paths(['/spec_dir/foo']).should == ['/__spec__/foo']
-    mapper.map_spec_paths(['foo/bar']).should == ['/__spec__/foo/bar']
+    expect(mapper.map_spec_paths(['/spec_dir/foo'])).to eq ['/__spec__/foo']
+    expect(mapper.map_spec_paths(['foo/bar'])).to eq ['/__spec__/foo/bar']
   end
   it "correctly remaps jasmine files" do
     config = double(:config, :jasmine_dir => '/jasmine_dir', :jasmine_path => '/__jasmine__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_jasmine_paths(['/jasmine_dir/foo']).should == ['/__jasmine__/foo']
-    mapper.map_jasmine_paths(['foo/bar']).should == ['/__jasmine__/foo/bar']
+    expect(mapper.map_jasmine_paths(['/jasmine_dir/foo'])).to eq ['/__jasmine__/foo']
+    expect(mapper.map_jasmine_paths(['foo/bar'])).to eq ['/__jasmine__/foo/bar']
   end
   it "correctly remaps boot files" do
     config = double(:config, :boot_dir => '/boot_dir', :boot_path => '/__boot__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_boot_paths(['/boot_dir/foo']).should == ['/__boot__/foo']
-    mapper.map_boot_paths(['foo/bar']).should == ['/__boot__/foo/bar']
+    expect(mapper.map_boot_paths(['/boot_dir/foo'])).to eq ['/__boot__/foo']
+    expect(mapper.map_boot_paths(['foo/bar'])).to eq ['/__boot__/foo/bar']
   end
   it "handles edge case where dir == path" do
     config = double(:config, :src_dir => '/src_dir', :src_path => '/src_dir')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_src_paths(['/src_dir/foo']).should == ['/src_dir/foo']
+    expect(mapper.map_src_paths(['/src_dir/foo'])).to eq ['/src_dir/foo']
   end
   it 'handles edge case with multiple instances of src dir' do
     config = double(:config, :src_dir => '/app', :src_path => '/')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_src_paths(['/app/assets/application.js']).should == ['/assets/application.js']
+    expect(mapper.map_src_paths(['/app/assets/application.js'])).to eq ['/assets/application.js']
   end
 end

data/spec/performance/phantom_js_runner_performance_spec.rb

@@ -18,6 +18,6 @@ describe "Phantom JS Runner performance/integration suite", :performance => true
     FileUtils.cp(File.join(@root, 'spec', 'fixture', 'large_test_suite_spec.js'), File.join(@tmp, 'spec', 'javascripts'))
 
     ci_output = `rake --trace jasmine:ci`
-    ci_output.should =~ (/40000 specs, 20000 failures/)
+    expect(ci_output).to match (/40000 specs, 20000 failures/)
   end
 end

data/spec/rack/jasmine/runner_spec.rb

@@ -11,14 +11,14 @@ describe Rack::Jasmine::Runner do
       let(:expected_headers) { {"Content-Type" => "text/html"} }
       let(:path) { "/" }
       it "should return a response with the passed content" do
-        subject.should == [200, expected_headers, [content]]
+        expect(subject).to eq [200, expected_headers, [content]]
       end
     end
     context "PATH_INFO is not /" do
       let(:path) { "/some_foo" }
       let(:expected_headers) { {"Content-Type" => "text/plain", "X-Cascade" => "pass"} }
       it "should return a 404" do
-        subject.should == [404, expected_headers, ["File not found: #{path}\n"]]
+        expect(subject).to eq [404, expected_headers, ["File not found: #{path}\n"]]
       end
     end
   end

data/spec/result_spec.rb

@@ -5,8 +5,8 @@ describe Jasmine::Result do
     it "exposes failed expectations" do
       result = Jasmine::Result.new(failing_raw_result)
       expectation = result.failed_expectations[0]
-      expectation.message.should == "a failure message"
-      expectation.stack.should == "a stack trace"
+      expect(expectation.message).to eq "a failure message"
+      expect(expectation.stack).to eq "a stack trace"
     end
 
     it "exposes only the last 7 lines of the stack trace" do
@@ -15,10 +15,10 @@ describe Jasmine::Result do
 
       result = Jasmine::Result.new(raw_result)
       expectation = result.failed_expectations[0].stack
-      expectation.should match(/1/)
-      expectation.should match(/7/)
-      expectation.should_not match(/8/)
-      expectation.should_not match(/9/)
+      expect(expectation).to match(/1/)
+      expect(expectation).to match(/7/)
+      expect(expectation).to_not match(/8/)
+      expect(expectation).to_not match(/9/)
     end
 
     it "exposes the full stack trace when configured" do
@@ -28,7 +28,7 @@ describe Jasmine::Result do
 
       result = Jasmine::Result.new(raw_result.merge!("show_full_stack_trace" => true))
       expectation = result.failed_expectations[0].stack
-      expectation.should == stack_trace
+      expect(expectation).to eq stack_trace
     end
 
     it "handles failed specs with no stack trace" do
@@ -36,7 +36,7 @@ describe Jasmine::Result do
 
       result = Jasmine::Result.new(raw_result)
       expectation = result.failed_expectations[0].stack
-      expectation.should match(/No stack/)
+      expect(expectation).to match(/No stack/)
     end
 
   end

data/spec/server_spec.rb

@@ -1,58 +1,22 @@
 require 'spec_helper'
 
 describe Jasmine::Server do
-  describe "rack ~> 1.0" do
-    before do
-      allow(Jasmine::Dependencies).to receive(:legacy_rack?).and_return(true)
-    end
-
-    it "should run the handler with the application" do
-      server = double(:server)
-      port = 1234
-      fake_env = {}
-      application = double(:application)
-      expect(Rack::Handler).to receive(:get).with("webrick").and_return(server)
-      expect(server).to receive(:run).with(application, hash_including(:Port => port))
-      Jasmine::Server.new(port, application, nil, fake_env).start
-      expect(fake_env['PORT']).to eq('1234')
+  before do
+    if !Rack.constants.include?(:Server)
+      Rack::Server = double("Rack::Server")
     end
+    @fake_env = {}
   end
 
-  describe "rack >= 1.1" do
-    before do
-      allow(Jasmine::Dependencies).to receive(:legacy_rack?).and_return(false)
-      if !Rack.constants.include?(:Server)
-        Rack::Server = double("Rack::Server")
-      end
-      @fake_env = {}
-    end
-
-    it "should create a Rack::Server with the correct port when passed" do
-      port = 1234
-      expect(Rack::Server).to receive(:new).with(hash_including(:Port => port)).and_return(double(:server).as_null_object)
-      Jasmine::Server.new(port, double(:app), nil, @fake_env).start
-    end
-
-    it "should start the server" do
-      server = double(:server)
-      expect(Rack::Server).to receive(:new) { server.as_null_object }
-      expect(server).to receive(:start)
-      Jasmine::Server.new('8888', double(:app), nil, @fake_env).start
-    end
-
-    it "should set the app as the instance variable on the rack server" do
-      app = double('application')
-      server = double(:server)
-      expect(Rack::Server).to receive(:new) { server.as_null_object }
-      Jasmine::Server.new(1234, app, nil, @fake_env).start
-      expect(server.instance_variable_get(:@app)).to eq app
-    end
+  it "should start the server" do
+    expect(Rack::Server).to receive(:start) { double(:server).as_null_object }
+    Jasmine::Server.new('8888', double(:app), nil, @fake_env).start
+  end
 
-    it "should pass rack options when starting the server" do
-      app = double('application')
-      expect(Rack::Server).to receive(:new).with(hash_including(:Port => 1234, :foo => 'bar')).and_return(double(:server).as_null_object)
-      Jasmine::Server.new(1234, app, {:foo => 'bar', :Port => 4321}, @fake_env).start
-      expect(@fake_env['PORT']).to eq('1234')
-    end
+  it "should pass rack options when starting the server" do
+    app = double('application')
+    expect(Rack::Server).to receive(:start).with(hash_including(:app => app, :Port => 1234, :foo => 'bar')).and_return(double(:server).as_null_object)
+    Jasmine::Server.new(1234, app, {:foo => 'bar', :Port => 4321}, @fake_env).start
+    expect(@fake_env['PORT']).to eq('1234')
   end
 end

data/spec/yaml_config_parser_spec.rb

@@ -8,7 +8,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.src_dir.should == 'some_project_root'
+    expect(parser.src_dir).to eq 'some_project_root'
   end
 
   it "src_dir returns src_dir if set" do
@@ -18,7 +18,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.src_dir.should == File.join('some_project_root', 'some_src_dir')
+    expect(parser.src_dir).to eq File.join('some_project_root', 'some_src_dir')
   end
 
   it "jasmine_dir returns nil when jasmine dir is blank" do
@@ -28,7 +28,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.jasmine_dir.should be_nil
+    expect(parser.jasmine_dir).to be_nil
   end
 
   it "jasmine_dir returns jasmine_dir if set" do
@@ -38,7 +38,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.jasmine_dir.should == File.join('some_project_root', 'some_jasmine_dir')
+    expect(parser.jasmine_dir).to eq File.join('some_project_root', 'some_jasmine_dir')
   end
 
   it "spec_helper returns default helper path when spec_helper is blank" do
@@ -48,7 +48,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.spec_helper.should == 'some_project_root/spec/javascripts/support/jasmine_helper.rb'
+    expect(parser.spec_helper).to eq 'some_project_root/spec/javascripts/support/jasmine_helper.rb'
   end
 
   it "spec_helper returns spec_helper if set" do
@@ -58,7 +58,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.spec_helper.should == 'some_project_root/some_spec_helper.rb'
+    expect(parser.spec_helper).to eq 'some_project_root/some_spec_helper.rb'
   end
 
   it "boot_dir returns nil when boot dir is blank" do
@@ -68,7 +68,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.boot_dir.should be_nil
+    expect(parser.boot_dir).to be_nil
   end
 
   it "boot_dir returns boot_dir if set" do
@@ -78,7 +78,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.boot_dir.should == File.join('some_project_root', 'some_boot_dir')
+    expect(parser.boot_dir).to eq File.join('some_project_root', 'some_boot_dir')
   end
 
   it "spec_dir uses default path when spec dir is blank" do
@@ -88,7 +88,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.spec_dir.should == File.join('some_project_root', 'spec', 'javascripts')
+    expect(parser.spec_dir).to eq File.join('some_project_root', 'spec', 'javascripts')
   end
 
   it "spec_dir returns spec_dir if set" do
@@ -98,7 +98,7 @@ describe Jasmine::YamlConfigParser do
       end
     end
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', nil, yaml_loader)
-    parser.spec_dir.should == File.join('some_project_root', 'some_spec_dir')
+    expect(parser.spec_dir).to eq File.join('some_project_root', 'some_spec_dir')
   end
 
   it "expands src_file paths" do
@@ -115,7 +115,7 @@ describe Jasmine::YamlConfigParser do
 
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', expander, yaml_loader)
 
-    parser.src_files.should == ['expected_results']
+    expect(parser.src_files).to eq ['expected_results']
   end
 
   it "expands stylesheets paths" do
@@ -132,7 +132,7 @@ describe Jasmine::YamlConfigParser do
 
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', expander, yaml_loader)
 
-    parser.css_files.should == ['expected_results']
+    expect(parser.css_files).to eq ['expected_results']
   end
 
   it "expands spec_file paths" do
@@ -149,7 +149,7 @@ describe Jasmine::YamlConfigParser do
 
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', expander, yaml_loader)
 
-    parser.spec_files.should == ['expected_results']
+    expect(parser.spec_files).to eq ['expected_results']
   end
 
   it "expands jasmine_file paths" do
@@ -166,7 +166,7 @@ describe Jasmine::YamlConfigParser do
 
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', expander, yaml_loader)
 
-    parser.jasmine_files.should == ['expected_results']
+    expect(parser.jasmine_files).to eq ['expected_results']
   end
 
   it "expands boot_file paths" do
@@ -183,7 +183,7 @@ describe Jasmine::YamlConfigParser do
 
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', expander, yaml_loader)
 
-    parser.boot_files.should == ['expected_results']
+    expect(parser.boot_files).to eq ['expected_results']
   end
 
   it "expands jasmine css file paths" do
@@ -200,7 +200,7 @@ describe Jasmine::YamlConfigParser do
 
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', expander, yaml_loader)
 
-    parser.jasmine_css_files.should == ['expected_results']
+    expect(parser.jasmine_css_files).to eq ['expected_results']
   end
 
   it "expands helper paths" do
@@ -217,7 +217,7 @@ describe Jasmine::YamlConfigParser do
 
     parser = Jasmine::YamlConfigParser.new('some_path', 'some_project_root', expander, yaml_loader)
 
-    parser.helpers.should == ['expected_results']
+    expect(parser.helpers).to eq ['expected_results']
   end
 
   it "doesn't blow up when blank values are passed" do
@@ -230,10 +230,10 @@ describe Jasmine::YamlConfigParser do
     end
 
     parser = Jasmine::YamlConfigParser.new({}, 'some_project_root', expander, yaml_loader)
-    parser.src_files.should == []
-    parser.spec_files.should == []
-    parser.css_files.should == []
-    parser.helpers.should == []
+    expect(parser.src_files).to eq []
+    expect(parser.spec_files).to eq []
+    expect(parser.css_files).to eq []
+    expect(parser.helpers).to eq []
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jasmine
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Gregg Van Hove
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-24 00:00:00.000000000 Z
+date: 2017-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -86,7 +86,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: 2.7.0
     - - "<"
       - !ruby/object:Gem::Version
         version: 3.0.0
@@ -96,7 +96,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: 2.7.0
     - - "<"
       - !ruby/object:Gem::Version
         version: 3.0.0
@@ -192,6 +192,7 @@ files:
 - lib/jasmine/path_mapper.rb
 - lib/jasmine/railtie.rb
 - lib/jasmine/result.rb
+- lib/jasmine/ruby_versions.rb
 - lib/jasmine/run.html.erb
 - lib/jasmine/runners/phantom_boot.js
 - lib/jasmine/runners/phantom_jasmine_run.js
@@ -219,6 +220,8 @@ files:
 - release_notes/v2.5.1.md
 - release_notes/v2.5.2.md
 - release_notes/v2.6.0.md
+- release_notes/v2.6.1.md
+- release_notes/v2.7.0.md
 - spec/application_integration_spec.rb
 - spec/application_spec.rb
 - spec/base_spec.rb