ruby-virtualenv 0.5.0 → 0.5.1

data/spec/sandbox/output_spec.rb

@@ -5,139 +5,139 @@ describe 'including', Sandbox::Output do
     include Sandbox::Output
   end
   
-  before( :each ) do
+  before(:each) do
     Sandbox.instance_eval { instance_variables.each { |v| remove_instance_variable v } }
     @tester = Tester.new
   end
   
   it "should have tell method" do
-    @tester.should respond_to( :tell )
+    @tester.should respond_to(:tell)
   end
   
   it "should have tell_when_verbose method" do
-    @tester.should respond_to( :tell_when_verbose )
+    @tester.should respond_to(:tell_when_verbose)
   end
   
   it "should have tell_when_really_verbose method" do
-    @tester.should respond_to( :tell_when_really_verbose )
+    @tester.should respond_to(:tell_when_really_verbose)
   end
   
   it "should have tell_unless_quiet method" do
-    @tester.should respond_to( :tell_unless_quiet )
+    @tester.should respond_to(:tell_unless_quiet)
   end
   
   it "should have tell_unless_really_quiet method" do
-    @tester.should respond_to( :tell_unless_really_quiet )
+    @tester.should respond_to(:tell_unless_really_quiet)
   end
   
   describe "calling tell" do
     it "should require message" do
-      lambda { @tester.tell }.should raise_error( ArgumentError )
+      lambda { @tester.tell }.should raise_error(ArgumentError)
     end
     
     it "should call puts when normal" do
-      @tester.expects( :puts )
-      @tester.tell( "message" )
+      @tester.expects(:puts)
+      @tester.tell("message")
     end
     
     it "should not call puts when below normal verbosity" do
       Sandbox.decrease_verbosity
-      @tester.expects( :puts ).never
-      @tester.tell( "message" )
+      @tester.expects(:puts).never
+      @tester.tell("message")
     end
     
     it "should call puts when above normal verbosity" do
       Sandbox.increase_verbosity
-      @tester.expects( :puts )
-      @tester.tell( "message" )
+      @tester.expects(:puts)
+      @tester.tell("message")
     end
   end
   
   describe "calling tell_when_verbose" do
     it "should require message" do
-      lambda { @tester.tell_when_verbose }.should raise_error( ArgumentError )
+      lambda { @tester.tell_when_verbose }.should raise_error(ArgumentError)
     end
     
     it "should not call puts when normal verbosity" do
-      @tester.expects( :puts ).never
-      @tester.tell_when_verbose( "message" )
+      @tester.expects(:puts).never
+      @tester.tell_when_verbose("message")
     end
     
     it "should call puts when above normal verbosity" do
       Sandbox.increase_verbosity
-      @tester.expects( :puts )
-      @tester.tell_when_verbose( "message" )
+      @tester.expects(:puts)
+      @tester.tell_when_verbose("message")
     end
   end
   
   describe "calling tell_when_really_verbose" do
     it "should require message" do
-      lambda { @tester.tell_when_really_verbose }.should raise_error( ArgumentError )
+      lambda { @tester.tell_when_really_verbose }.should raise_error(ArgumentError)
     end
     
     it "should not call puts when normal verbosity" do
-      @tester.expects( :puts ).never
-      @tester.tell_when_really_verbose( "message" )
+      @tester.expects(:puts).never
+      @tester.tell_when_really_verbose("message")
     end
     
     it "should call puts when above normal verbosity" do
       Sandbox.increase_verbosity
-      @tester.expects( :puts ).never
-      @tester.tell_when_really_verbose( "message" )
+      @tester.expects(:puts).never
+      @tester.tell_when_really_verbose("message")
     end
     
     it "should call puts when really above normal verbosity" do
       Sandbox.increase_verbosity
       Sandbox.increase_verbosity
-      @tester.expects( :puts )
-      @tester.tell_when_really_verbose( "message" )
+      @tester.expects(:puts)
+      @tester.tell_when_really_verbose("message")
     end
   end
   
   describe "calling tell_unless_quiet" do
     it "should require message" do
-      lambda { @tester.tell_unless_quiet }.should raise_error( ArgumentError )
+      lambda { @tester.tell_unless_quiet }.should raise_error(ArgumentError)
     end
     
     it "should call puts when normal" do
-      @tester.expects( :puts )
-      @tester.tell_unless_quiet( "message" )
+      @tester.expects(:puts)
+      @tester.tell_unless_quiet("message")
     end
     
     it "should not call puts when below normal verbosity" do
       Sandbox.decrease_verbosity
-      @tester.expects( :puts ).never
-      @tester.tell_unless_quiet( "message" )
+      @tester.expects(:puts).never
+      @tester.tell_unless_quiet("message")
     end
     
     it "should call puts when above normal verbosity" do
       Sandbox.increase_verbosity
-      @tester.expects( :puts )
-      @tester.tell_unless_quiet( "message" )
+      @tester.expects(:puts)
+      @tester.tell_unless_quiet("message")
     end
   end
   
   describe "calling tell_unless_really_quiet" do
     it "should require message" do
-      lambda { @tester.tell_unless_really_quiet }.should raise_error( ArgumentError )
+      lambda { @tester.tell_unless_really_quiet }.should raise_error(ArgumentError)
     end
     
     it "should call puts when normal" do
-      @tester.expects( :puts )
-      @tester.tell_unless_really_quiet( "message" )
+      @tester.expects(:puts)
+      @tester.tell_unless_really_quiet("message")
     end
     
     it "should call puts when below normal verbosity" do
       Sandbox.decrease_verbosity
-      @tester.expects( :puts )
-      @tester.tell_unless_really_quiet( "message" )
+      @tester.expects(:puts)
+      @tester.tell_unless_really_quiet("message")
     end
     
     it "should not call puts when really below normal verbosity" do
       Sandbox.decrease_verbosity
       Sandbox.decrease_verbosity
-      @tester.expects( :puts ).never
-      @tester.tell_unless_really_quiet( "message" )
+      @tester.expects(:puts).never
+      @tester.tell_unless_really_quiet("message")
     end
   end
   

data/spec/sandbox_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Sandbox do
 
-  before( :each ) do
+  before(:each) do
     Sandbox.instance_eval { instance_variables.each { |v| remove_instance_variable(v) } }
   end
 

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-$:.unshift( File.dirname( __FILE__ ) + '/../lib' )
+$:.unshift(File.dirname(__FILE__) + '/../lib')
 
 require 'rubygems'
 require 'mocha'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-virtualenv
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
   prerelease: 
 platform: ruby
 authors:
@@ -14,7 +14,7 @@ date: 2011-10-02 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70170803900960 !ruby/object:Gem::Requirement
+  requirement: &70190793241640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 2.6.0
   type: :development
   prerelease: false
-  version_requirements: *70170803900960
+  version_requirements: *70190793241640
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70170803899420 !ruby/object:Gem::Requirement
+  requirement: &70190793240980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,7 +33,7 @@ dependencies:
         version: 0.10.0
   type: :development
   prerelease: false
-  version_requirements: *70170803899420
+  version_requirements: *70190793240980
 description: Create virtual ruby/rubygems environments.
 email:
 - nkryptic@gmail.com
@@ -52,9 +52,6 @@ files:
 - Rakefile
 - TODO
 - bin/ruby-virtualenv
-- features/development.feature
-- features/steps/common.rb
-- features/steps/env.rb
 - lib/sandbox.rb
 - lib/sandbox/cli.rb
 - lib/sandbox/errors.rb
@@ -70,7 +67,7 @@ files:
 - spec/sandbox/output_spec.rb
 - spec/sandbox_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/fesplugas/ruby-virtualenv
+homepage: https://github.com/fesplugas/ruby-virtualenv
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -95,9 +92,6 @@ signing_key:
 specification_version: 3
 summary: Create virtual ruby/rubygems environments.
 test_files:
-- features/development.feature
-- features/steps/common.rb
-- features/steps/env.rb
 - spec/sandbox/cli_spec.rb
 - spec/sandbox/errors_spec.rb
 - spec/sandbox/installer_spec.rb

data/features/development.feature

@@ -1,13 +0,0 @@
-Feature: Development processes of newgem itself (rake tasks)
-
-  As a Newgem maintainer or contributor
-  I want rake tasks to maintain and release the gem
-  So that I can spend time on the tests and code, and not excessive time on maintenance processes
-    
-  Scenario: Generate RubyGem
-    Given this project is active project folder
-    And 'pkg' folder is deleted
-    When task 'rake gem' is invoked
-    Then folder 'pkg' is created
-    And file with name matching 'pkg/*.gem' is created else you should run "rake manifest" to fix this
-    And gem spec key 'rdoc_options' contains /--mainREADME.rdoc/

data/features/steps/common.rb

@@ -1,174 +0,0 @@
-def in_project_folder(&block)
-  project_folder = @active_project_folder || @tmp_root
-  FileUtils.chdir(project_folder, &block)
-end
-
-def in_home_folder(&block)
-  FileUtils.chdir(@home_path, &block)
-end
-
-Given %r{^a safe folder} do
-  FileUtils.rm_rf   @tmp_root = File.dirname(__FILE__) + "/../../tmp"
-  FileUtils.mkdir_p @tmp_root
-  FileUtils.mkdir_p @home_path = File.expand_path(File.join(@tmp_root, "home"))
-  @lib_path = File.expand_path(File.dirname(__FILE__) + '/../../lib')
-  Given "env variable $HOME set to '#{@home_path}'"
-end
-
-Given %r{^this project is active project folder} do
-  Given "a safe folder"
-  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
-end
-
-Given %r{^env variable \$([\w_]+) set to '(.*)'} do |env_var, value|
-  ENV[env_var] = value
-end
-
-def force_local_lib_override(project_name = @project_name)
-  rakefile = File.read(File.join(project_name, 'Rakefile'))
-  File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
-    f << "$:.unshift('#{@lib_path}')\n"
-    f << rakefile
-  end
-end
-
-def setup_active_project_folder project_name
-  @active_project_folder = File.join(@tmp_root, project_name)
-  @project_name = project_name
-end
-
-Given %r{'(.*)' folder is deleted} do |folder|
-  in_project_folder do
-    FileUtils.rm_rf folder
-  end
-end
-
-When %r{^'(.*)' generator is invoked with arguments '(.*)'$} do |generator, arguments|
-  FileUtils.chdir(@active_project_folder) do
-    if Object.const_defined?("APP_ROOT")
-      APP_ROOT.replace(FileUtils.pwd)
-    else 
-      APP_ROOT = FileUtils.pwd
-    end
-    run_generator(generator, arguments.split(' '), SOURCES)
-  end
-end
-
-When %r{run executable '(.*)' with arguments '(.*)'} do |executable, arguments|
-  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
-  FileUtils.chdir(@active_project_folder) do
-    system "ruby #{executable} #{arguments} > #{@stdout}"
-  end
-end
-
-When %r{^task 'rake (.*)' is invoked$} do |task|
-  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
-  FileUtils.chdir(@active_project_folder) do
-    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
-  end
-end
-
-Then %r{^folder '(.*)' is created} do |folder|
-  in_project_folder do
-    File.exists?(folder).should be_true
-  end
-end
-
-Then %r{^file '(.*)' (is|is not) created} do |file, is|
-  in_project_folder do
-    File.exists?(file).should(is == 'is' ? be_true : be_false)
-  end
-end
-
-Then %r{^file with name matching '(.*)' is created} do |pattern|
-  in_project_folder do
-    Dir[pattern].should_not be_empty
-  end
-end
-
-Then %r{gem file '(.*)' and generated file '(.*)' should be the same} do |gem_file, project_file|
-  File.exists?(gem_file).should be_true
-  File.exists?(project_file).should be_true
-  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
-  project_file_contents = File.read(File.join(@active_project_folder, project_file))
-  project_file_contents.should == gem_file_contents
-end
-
-Then %r{^output same as contents of '(.*)'$} do |file|
-  expected_output = File.read(File.join(File.dirname(__FILE__) + "/../expected_outputs", file))
-  actual_output = File.read(File.dirname(__FILE__) + "/../../tmp/#{@stdout}")
-  actual_output.should == expected_output
-end
-
-Then %r{^(does|does not) invoke generator '(.*)'$} do |does_invoke, generator|
-  actual_output = File.read(File.dirname(__FILE__) + "/../../tmp/#{@stdout}")
-  does_invoke == "does" ?
-    actual_output.should(match(/dependency\s+#{generator}/)) :
-    actual_output.should_not(match(/dependency\s+#{generator}/))
-end
-
-Then %r{help options '(.*)' and '(.*)' are displayed} do |opt1, opt2|
-  actual_output = File.read(@stdout)
-  actual_output.should match(/#{opt1}/)
-  actual_output.should match(/#{opt2}/)
-end
-
-Then %r{^output (does|does not) match \/(.*)\/} do |does, regex|
-  actual_output = File.read(@stdout)
-  (does == 'does') ?
-    actual_output.should(match(/#{regex}/)) :
-    actual_output.should_not(match(/#{regex}/)) 
-end
-
-Then %r{^contents of file '(.*)' (does|does not) match \/(.*)\/} do |file, does, regex|
-  in_project_folder do
-    actual_output = File.read(file)
-    (does == 'does') ?
-      actual_output.should(match(/#{regex}/)) :
-      actual_output.should_not(match(/#{regex}/))
-  end
-end
-
-Then %r{^all (\d+) tests pass} do |expected_test_count|
-  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
-  actual_output = File.read(@stdout)
-  actual_output.should match(expected)
-end
-
-Then %r{^all (\d+) examples pass} do |expected_test_count|
-  expected = %r{^#{expected_test_count} examples?, 0 failures}
-  actual_output = File.read(@stdout)
-  actual_output.should match(expected)
-end
-
-Then %r{^yaml file '(.*)' contains (\{.*\})} do |file, yaml|
-  in_project_folder do
-    yaml = eval yaml
-    YAML.load(File.read(file)).should == yaml
-  end
-end
-
-Then %r{^Rakefile can display tasks successfully} do
-  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
-  FileUtils.chdir(@active_project_folder) do
-    system "rake -T > #{@stdout} 2> #{@stdout}"
-  end
-  actual_output = File.read(@stdout)
-  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
-end
-
-Then %r{^task 'rake (.*)' is executed successfully} do |task|
-  @stdout.should_not be_nil
-  actual_output = File.read(@stdout)
-  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
-  actual_output.should_not match(/Error/i)
-end
-
-Then %r{^gem spec key '(.*)' contains \/(.*)\/} do |key, regex|
-  in_project_folder do
-    gem_file = Dir["pkg/*.gem"].first
-    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
-    spec_value = gem_spec.send(key.to_sym)
-    spec_value.to_s.should match(/#{regex}/)
-  end
-end