zassets 0.2.5 → 0.2.6

data/features/step_definitions/builder_steps.rb

@@ -36,6 +36,6 @@ end
 
 Then /^it should build$/ do
   prep_for_fs_check do
-    File.exist?('public/assets/manifest.json').should be_true
+    File.exist?('public/assets/manifest.json').should be_truthy
   end
 end

data/lib/zassets/version.rb

@@ -1,3 +1,3 @@
 module ZAssets
-  VERSION = '0.2.5'
+  VERSION = '0.2.6'
 end

data/spec/zassets/builder_spec.rb

@@ -8,14 +8,14 @@ module ZAssets
     describe '#build' do
       it 'compiles the manifest' do
         builder.manifest = double('manifest')
-        builder.manifest.should_receive :compile
+        expect(builder.manifest).to receive :compile
         builder.build
       end
     end
 
     describe '#manifest' do
       it 'builds a sprockets manifest' do
-        Sprockets::Manifest.should_receive(:new).with(
+        expect(Sprockets::Manifest).to receive(:new).with(
           builder.environment,
           builder.manifest_path
         )
@@ -24,30 +24,28 @@ module ZAssets
 
       it 'returns the sprockets manifest' do
         manifest = double('manifest')
-        Sprockets::Manifest.stub(:new) { manifest }
-        builder.manifest.should == manifest
+        allow(Sprockets::Manifest).to receive(:new) { manifest }
+        expect(builder.manifest).to be manifest
       end
     end
 
     describe '#manifest_path' do
       it 'returns the manifest file path' do
-        builder.manifest_path.should == File.join(
-          config[:build_path],
-          'manifest.json'
-        )
+        expected_path = File.join(config[:build_path], 'manifest.json')
+        expect(builder.manifest_path).to eq expected_path
       end
     end
 
     describe '#environment' do
       it 'builds a sprockets env' do
-        SprocketsEnv.should_receive(:new).with(config)
+        expect(SprocketsEnv).to receive(:new).with(config)
         builder.environment
       end
 
       it 'returns the sprockets env' do
         environment = double('environment')
-        SprocketsEnv.stub(:new) { environment }
-        builder.environment.should == environment
+        allow(SprocketsEnv).to receive(:new) { environment }
+        expect(builder.environment).to be environment
       end
     end
   end

data/spec/zassets/cli_spec.rb

@@ -8,19 +8,19 @@ module ZAssets
     describe '#initialize' do
       context 'action arguments parsing' do
         it 'parses the action' do
-          cli.action.should == :serve
+          expect(cli.action).to eq :serve
         end
 
         context 'when action is not provided' do
           let(:args) { [] }
 
           it 'defaults to build' do
-            cli.action.should == :build
+            expect(cli.action).to eq :build
           end
         end
       end
 
-      context 'option arguments parsing ' do
+      context 'option arguments parsing' do
         def with_option(option, value = nil)
           if value
             CLI.new [option, value, *args]
@@ -30,23 +30,24 @@ module ZAssets
         end
 
         it 'parses the -v option' do
-          with_option('-v').options[:verbose].should be_true
+          expect(with_option('-v').options[:verbose]).to be true
         end
 
         it 'parses the -c option' do
-          with_option('-c', 'config').options[:config_file].should == 'config'
+          expect(with_option('-c', 'config').options[:config_file])
+            .to eq 'config'
         end
 
         it 'parses the -o option' do
-          with_option('-o', '::0').options[:host].should == '::0'
+          expect(with_option('-o', '::0').options[:host]).to eq '::0'
         end
 
         it 'parses the -p option' do
-          with_option('-p', '9393').options[:port].should == '9393'
+          expect(with_option('-p', '9393').options[:port]).to eq '9393'
         end
 
         it 'parses the -s option' do
-          with_option('-s', 'thin').options[:server].should == 'thin'
+          expect(with_option('-s', 'thin').options[:server]).to eq 'thin'
         end
 
         context '-h option' do
@@ -59,11 +60,11 @@ module ZAssets
               cli
             rescue SystemExit
             end
-            output.string.should =~ /\AUsage: /
+            expect(output.string).to match /\AUsage: /
           end
 
           it 'exits' do
-            lambda { cli }.should raise_error SystemExit
+            expect { cli }.to raise_error SystemExit
           end
         end
 
@@ -77,11 +78,11 @@ module ZAssets
               cli
             rescue SystemExit
             end
-            output.string.chomp.should == VERSION
+            expect(output.string.chomp).to eq VERSION
           end
 
           it 'exits' do
-            lambda { cli }.should raise_error SystemExit
+            expect { cli }.to raise_error SystemExit
           end
         end
       end
@@ -89,20 +90,20 @@ module ZAssets
 
     describe '#action' do
       it 'return the current action' do
-        cli.action.should == args.last.to_sym
+        expect(cli.action).to eq args.last.to_sym
       end
     end
 
     describe '#config' do
       it 'builds a config' do
-        Config.should_receive(:new).with(cli.options)
+        expect(Config).to receive(:new).with(cli.options)
         cli.config
       end
 
       it 'returns the config' do
         config = double('config')
-        Config.stub(:new) { config }
-        cli.config.should == config
+        allow(Config).to receive(:new) { config }
+        expect(cli.config).to be config
       end
     end
 
@@ -110,8 +111,8 @@ module ZAssets
       context 'serve action' do
         it 'runs the server' do
           server = double('server')
-          cli.stub(:server) { server }
-          server.should_receive :run
+          allow(cli).to receive(:server) { server }
+          expect(server).to receive :run
           cli.run
         end
       end
@@ -121,8 +122,8 @@ module ZAssets
 
         it 'runs the builder' do
           builder = double('builder')
-          cli.stub(:builder) { builder }
-          builder.should_receive :build
+          allow(cli).to receive(:builder) { builder }
+          expect(builder).to receive :build
           cli.run
         end
       end
@@ -130,27 +131,27 @@ module ZAssets
 
     describe '#builder' do
       it 'builds a builder' do
-        Builder.should_receive(:new).with(cli.config)
+        expect(Builder).to receive(:new).with(cli.config)
         cli.builder
       end
 
       it 'returns the builder' do
         builder = double('builder')
-        Builder.stub(:new) { builder }
-        cli.builder.should == builder
+        allow(Builder).to receive(:new) { builder }
+        expect(cli.builder).to be builder
       end
     end
 
     describe '#server' do
       it 'builds a server' do
-        Server.should_receive(:new).with(cli.config)
+        expect(Server).to receive(:new).with(cli.config)
         cli.server
       end
 
       it 'returns the server' do
         server = double('server')
-        Server.stub(:new) { server }
-        cli.server.should == server
+        allow(Server).to receive(:new) { server }
+        expect(cli.server).to be server
       end
     end
   end

data/spec/zassets/config_spec.rb

@@ -9,18 +9,18 @@ module ZAssets
 
     describe '#initialize' do
       it 'assigns #default_options to @options' do
-        config.instance_eval { @options }.should == config.default_options
+        expect(config.instance_eval { @options }).to eq config.default_options
       end
 
       it 'registers plugins' do
-        Config.any_instance.should_receive :register_plugins!
+        expect_any_instance_of(Config).to receive :register_plugins!
         Config.new
       end
 
       context 'with a non-empty option hash' do
         it 'merges the option hash' do
           config = Config.new(verbose: true)
-          config[:verbose].should == true
+          expect(config[:verbose]).to be true
         end
       end
 
@@ -28,60 +28,60 @@ module ZAssets
         subject(:config) { Config.new(config_file: config_file) }
 
         it 'merges the config file options in @options' do
-          config[:file_option].should == :file_value
+          expect(config[:file_option]).to eq :file_value
         end
 
         it 'merges the config file options before argument options' do
           config = Config.new(file_option: :argument_value)
-          config[:file_option].should == :argument_value
+          expect(config[:file_option]).to eq :argument_value
         end
       end
     end
 
     describe '#default_options' do
       it 'sets verbose to false' do
-        config.default_options[:verbose].should be_false
+        expect(config.default_options[:verbose]).to be false
       end
 
       it 'sets host to ::1' do
-        config.default_options[:host].should == '::1'
+        expect(config.default_options[:host]).to eq '::1'
       end
 
       it 'sets port to 9292' do
-        config.default_options[:port].should == 9292
+        expect(config.default_options[:port]).to eq 9292
       end
 
       it 'sets server to puma' do
-        config.default_options[:server].should == :puma
+        expect(config.default_options[:server]).to eq :puma
       end
 
       it 'sets base_url to /assets' do
-        config.default_options[:base_url].should == '/assets'
+        expect(config.default_options[:base_url]).to eq '/assets'
       end
 
       it 'sets paths to app directory' do
-        config.default_options[:paths].should == ['app']
+        expect(config.default_options[:paths]).to eq ['app']
       end
 
       it 'sets public_path to public directory' do
-        config.default_options[:public_path].should == 'public'
+        expect(config.default_options[:public_path]).to eq 'public'
       end
 
       it 'sets build_path to public/assets directory' do
-        config.default_options[:build_path].should == 'public/assets'
+        expect(config.default_options[:build_path]).to eq 'public/assets'
       end
 
       it 'sets build empty' do
-        config.default_options[:build].should == []
+        expect(config.default_options[:build]).to eq []
       end
     end
 
     describe '#load_options' do
       context 'when path is given as argument' do
         it 'loads symbolized options from YAML file' do
-          config.load_options(config_file).should == {
+          expect(config.load_options(config_file)).to eq({
             file_option: :file_value
-          }
+          })
         end
       end
 
@@ -96,14 +96,14 @@ module ZAssets
     describe '#default_config_file?' do
       context 'when file does not exist' do
         it 'returns false' do
-          config.default_config_file?.should be_false
+          expect(config.default_config_file?).to be false
         end
       end
 
       context 'when file exists' do
         it 'returns true' do
           within_fixture_path do
-            config.default_config_file?.should be_true
+            expect(config.default_config_file?).to be true
           end
         end
       end
@@ -114,24 +114,25 @@ module ZAssets
 
       it 'loads plugins' do
         config
-        Plugins::Dummy.should be
+        expect(Plugins::Dummy).to be
       end
 
       it 'registers them with current config' do
-        config[:dummy_plugin].should == :registered
-        config = Config.new(plugins: ['dummy'])
+        expect(config[:dummy_plugin]).to eq :registered
       end
     end
 
     describe '#[]' do
       it 'returns an @options value from its key' do
         config.instance_eval { @options[:foo] = :bar }
-        config[:foo].should == :bar
+        expect(config[:foo]).to eq :bar
       end
+    end
 
+    describe '#[]=' do
       it 'stores a value under given key' do
         config[:foo] = :bar
-        config[:foo].should == :bar
+        expect(config[:foo]).to eq :bar
       end
     end
   end

data/spec/zassets/memory_file_spec.rb

@@ -1,44 +1,46 @@
 require 'spec_helper'
 
-describe ZAssets::MemoryFile do
-  include FixturesHelpers
-
-  let(:file_path) { fixture_path_for('public/index.html') }
-  let(:file)      { File.new file_path }
-  let(:subject)   { described_class.new(file) }
-
-  describe '#headers' do
-    it 'sets the content type to text/html' do
-      subject.headers['Content-Type'].should == 'text/html'
-    end
-
-    it 'sets the content length to the file length' do
-      subject.headers['Content-Length'].should == file.size.to_s
+module ZAssets
+  describe MemoryFile do
+    include FixturesHelpers
+
+    let(:file_path)   { fixture_path_for('public/index.html') }
+    let(:file)        { File.new file_path }
+    subject(:memfile) { MemoryFile.new(file) }
+
+    describe '#headers' do
+      it 'sets the content type to text/html' do
+        expect(memfile.headers['Content-Type']).to eq 'text/html'
+      end
+
+      it 'sets the content length to the file length' do
+        expect(memfile.headers['Content-Length']).to eq file.size.to_s
+      end
     end
-  end
 
-  describe '#body' do
-    it 'returns the file content' do
-      subject.body.should == File.read(file_path)
+    describe '#body' do
+      it 'returns the file content' do
+        expect(memfile.body).to eq File.read(file_path)
+      end
     end
-  end
 
-  describe '#call' do
-    require 'rack'
+    describe '#call' do
+      require 'rack'
 
-    let(:app)       { Rack::MockRequest.new(subject) }
-    let(:response)  { app.get('/') }
+      let(:app)       { Rack::MockRequest.new(memfile) }
+      let(:response)  { app.get '/' }
 
-    it 'returns a successful response' do
-      response.should be_ok
-    end
+      it 'returns a successful response' do
+        expect(response).to be_ok
+      end
 
-    it 'sets required headers' do
-      response.headers.should == subject.headers
-    end
+      it 'sets required headers' do
+        expect(response.headers).to eq memfile.headers
+      end
 
-    it 'returns the body' do
-      response.body.should == subject.body
+      it 'returns the body' do
+        expect(response.body).to eq memfile.body
+      end
     end
   end
 end

data/spec/zassets/server_spec.rb

@@ -9,35 +9,35 @@ module ZAssets
       let(:handler) { double 'handler' }
 
       it 'runs the rack app' do
-        server.stub(:handler) { handler }
-        handler.should_receive(:run).with(server.app, server.options)
+        allow(server).to receive(:handler) { handler }
+        expect(handler).to receive(:run).with(server.app, server.options)
         server.run
       end
     end
 
     describe '#handler' do
       it 'returns the configured rack handler' do
-        server.handler.should == Rack::Handler::Puma
+        expect(server.handler).to eq Rack::Handler::Puma
       end
     end
 
     describe '#options' do
       it 'sets rack environment to development' do
-        server.options[:environment].should == :development
+        expect(server.options[:environment]).to eq :development
       end
 
       it 'sets rack handler host to configured host' do
-        server.options[:Host].should == config[:host]
+        expect(server.options[:Host]).to eq config[:host]
       end
 
       it 'sets rack handler port to configured port' do
-        server.options[:Port].should == config[:port]
+        expect(server.options[:Port]).to eq config[:port]
       end
     end
 
     describe '#app' do
       it 'returns a rack application' do
-        server.app.should respond_to(:call)
+        expect(server.app).to respond_to :call
       end
 
       it 'builds the rack app once' do
@@ -45,45 +45,48 @@ module ZAssets
         # built on each request. We dont want that so we need to either build
         # using Rack::Builder.app or call #to_app on the returned instance. We
         # can test if it was done by checking #to_app method absence.
-        server.app.should_not respond_to(:to_app)
+        expect(server.app).not_to respond_to :to_app
       end
 
       context 'Rack application' do
         include FixturesHelpers
 
-        let(:app) { Rack::MockRequest.new(server.app) }
+        let(:app)       { Rack::MockRequest.new(server.app) }
+        let(:path)      { '/' }
+        let(:response)  { app.get path }
 
         it 'logs queries' do
-          app.get('/').errors.should =~ /GET \/.+404.+/
+          expect(app.get('/').errors).to match(/GET \/.+404.+/)
         end
 
         it 'shows exceptions' do
-          SprocketsEnv.any_instance.stub(:call) { raise RuntimeError }
+          allow_any_instance_of(SprocketsEnv).to receive(:call) { raise RuntimeError }
           response = app.get(config[:base_url])
-          response.should be_server_error
-          response.should =~ /RuntimeError/
+          expect(response).to be_server_error
+          expect(response).to match /RuntimeError/
         end
 
         context 'assets mount point' do
-          let(:config) { Config.new(paths: [fixture_path_for('assets')]) }
+          let(:path)    { [config[:base_url], 'app.js'].join '/' }
+          let(:config)  { Config.new(paths: [fixture_path_for('assets')]) }
 
           it 'maps the sprockets env' do
             within_fixture_path do
-              response = app.get([config[:base_url], 'app.js'].join('/'))
-              response.should be_ok
-              response.content_type.should == 'application/javascript'
-              response.body.should == "console.log('hello!');\n"
+              expect(response).to be_ok
+              expect(response.content_type).to eq 'application/javascript'
+              expect(response.body).to eq "console.log('hello!');\n"
             end
           end
         end
 
         context 'root mount point' do
+          let(:path) { '/hello.txt' }
+
           it 'maps the static file handler' do
             within_fixture_path do
-              response = app.get('/hello.txt')
-              response.should be_ok
-              response.content_type.should == 'text/plain'
-              response.body.should == "hello!\n"
+              expect(response).to be_ok
+              expect(response.content_type).to eq 'text/plain'
+              expect(response.body).to eq "hello!\n"
             end
           end
 
@@ -93,9 +96,9 @@ module ZAssets
             it 'serves the public file' do
               within_fixture_path do
                 response = app.get('/')
-                response.should be_ok
-                response.content_type.should == 'text/html'
-                response.body.should == "hello HTML!\n"
+                expect(response).to be_ok
+                expect(response.content_type).to eq 'text/html'
+                expect(response.body).to eq "hello HTML!\n"
               end
             end
           end

data/spec/zassets/sprockets_env_spec.rb

@@ -7,14 +7,14 @@ module ZAssets
 
     describe 'working directory' do
       it 'initializes with current working directory' do
-        env.root.should == Dir.pwd
+        expect(env.root).to eq Dir.pwd
       end
     end
 
     describe 'logger level' do
       context 'by default' do
         it 'defaults to fatal' do
-          env.logger.level.should == Logger::FATAL
+          expect(env.logger.level).to eq Logger::FATAL
         end
       end
 
@@ -22,7 +22,7 @@ module ZAssets
         let(:config) { Config.new(verbose: true)}
 
         it 'is set to debug' do
-          env.logger.level.should == Logger::DEBUG
+          expect(env.logger.level).to eq Logger::DEBUG
         end
       end
     end
@@ -32,8 +32,12 @@ module ZAssets
       let(:config)  { Config.new(paths: paths) }
 
       it 'registers the configured search paths' do
-        env.paths.should include(File.join(env.root, paths[0]))
-        env.paths.should include(File.join(env.root, paths[1]))
+        # FIXME: We should not need to check against absolute paths (must never
+        # be needed or used).
+        expect(env.paths).to match_array [
+          File.join(env.root, paths[0]),
+          File.join(env.root, paths[1])
+        ]
       end
     end
   end

data/zassets.gemspec

@@ -6,9 +6,7 @@ Gem::Specification.new do |s|
   s.name        = 'zassets'
   s.version     = ZAssets::VERSION
   s.summary     = "zassets-#{ZAssets::VERSION}"
-  s.description = <<-eoh.gsub(/^ +/, '')
-    Standalone asset pipeline based on sprockets.
-  eoh
+  s.description = 'Assets server and builder'
   s.homepage    = 'https://rubygems.org/gems/zassets'
 
   s.author      = 'Thibault Jouan'
@@ -24,7 +22,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'execjs',        '~> 2.0.2'
   s.add_dependency 'coffee-script', '~> 2.2.0'
 
-  s.add_development_dependency 'rspec',     '~> 2.14.1'
+  s.add_development_dependency 'rspec',     '~> 3.0.0.beta1'
   s.add_development_dependency 'cucumber',  '~> 1.3.10'
   s.add_development_dependency 'aruba',     '~> 0.5.3'
   s.add_development_dependency 'httparty',  '~> 0.12.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zassets
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-28 00:00:00.000000000 Z
+date: 2013-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sprockets
@@ -98,7 +98,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.0.0.beta1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -106,7 +106,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.0.0.beta1
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
@@ -171,9 +171,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! 'Standalone asset pipeline based on sprockets.
-
-'
+description: Assets server and builder
 email: tj@a13.fr
 executables:
 - zassets
@@ -255,7 +253,7 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: zassets-0.2.5
+summary: zassets-0.2.6
 test_files:
 - spec/fixtures/assets/app.js
 - spec/fixtures/config/zassets.yaml