alias 0.2.1 → 0.2.2

data/test/console_test.rb

@@ -1,60 +1,63 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
-class Alias::ConsoleTest < Test::Unit::TestCase
-  before(:all) { @console = Object.new.extend(Alias::Console) }
+describe "Console" do
+  before { @console = nil }
+  def console
+    console ||= Object.new.extend(Console)
+  end
 
-  test "create_aliases doesn't save failed alias creation" do
-    capture_stderr { @console.create_aliases :blah, {} }
+  it "create_aliases doesn't save failed alias creation" do
+    capture_stderr { console.create_aliases :blah, {} }
     Alias.manager.instance_eval("@created_aliases").should == {}
   end
 
-  test "create_aliases takes partial creator names" do
+  it "create_aliases takes partial creator names" do
     Alias.manager.expects(:create_aliases).with(:instance_method, {}, anything)
-    @console.create_aliases(:in, {})
+    console.create_aliases(:in, {})
   end
 
-  test "search_aliases lists aliases if given nothing" do
+  it "search_aliases lists aliases if given nothing" do
     Alias.manager.expects(:all_aliases)
-    @console.search_aliases
+    console.search_aliases
   end
 
-  context "save_aliases" do
-    before(:all) { eval "module ::Bluh; def blah; end; end" }
-    before(:each) { Alias.manager.instance_eval("@created_aliases = nil") }
+  describe "save_aliases" do
+    before_all { eval "module ::Bluh; def blah; end; end" }
+    before { Alias.manager.instance_eval("@created_aliases = nil") }
 
-    test "saves created aliases" do
+    it "saves created aliases" do
       hash = {"Bluh"=>{"blah"=>"bl"}}
-      @console.create_aliases :instance_method, hash
+      console.create_aliases :instance_method, hash
       File.expects(:exists?).returns(false)
       Alias.expects(:save_to_file).with("#{ENV['HOME']}/.alias.yml", {:aliases=>{:instance_method=>hash}}.to_yaml)
-      capture_stdout { @console.save_aliases }.should =~ /Save/
+      capture_stdout { console.save_aliases }.should =~ /Save/
     end
 
-    test "saves to given file" do
+    it "saves to given file" do
       hash = {"Bluh"=>{"blah"=>"b"}}
-      @console.create_aliases :instance_method, hash
+      console.create_aliases :instance_method, hash
       Alias.expects(:save_to_file).with("explicit", {:aliases=>{:instance_method=>hash}}.to_yaml)
-      capture_stdout { @console.save_aliases('explicit') }.should =~ /explicit/
+      capture_stdout { console.save_aliases('explicit') }.should =~ /explicit/
     end
 
-    test "prints message if nothing to save" do
-      capture_stdout { @console.save_aliases }.should =~ /Didn't save/
+    it "prints message if nothing to save" do
+      capture_stdout { console.save_aliases }.should =~ /Didn't save/
     end
 
-    test "saves aliases to config/alias.yml if config/ exists" do
+    it "saves aliases to config/alias.yml if config/ exists" do
       File.expects(:directory?).returns(true)
-      @console.create_aliases :instance_method, {"Bluh"=>{"blah"=>"b2"}}
+      console.create_aliases :instance_method, {"Bluh"=>{"blah"=>"b2"}}
       Alias.expects(:save_to_file).with("config/alias.yml", anything)
-      capture_stdout { @console.save_aliases }
+      capture_stdout { console.save_aliases }
     end
 
-    test "merges existing aliases with created aliases" do
+    it "merges existing aliases with created aliases" do
       hash = {"Bluh"=>{"blah"=>"b3"}}
-      @console.create_aliases :instance_method, hash
+      console.create_aliases :instance_method, hash
       Alias.expects(:read_config_file).returns({:aliases=>{:instance_method=>{"Bluh"=>{"bling"=>"bl"}}}})
       Alias.expects(:save_to_file).with("#{ENV['HOME']}/.alias.yml",
         {:aliases=>{:instance_method=>{"Bluh"=>{'bling'=>'bl', 'blah'=>'b3'}}}}.to_yaml)
-      capture_stdout { @console.save_aliases }
+      capture_stdout { console.save_aliases }
     end
   end
-end
+end

data/test/constant_creator_test.rb

@@ -1,38 +1,36 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
-class Alias::Creators::ConstantCreatorTest < Test::Unit::TestCase
-  context "AliasConstantCreator" do
-    before(:each) { @manager = Alias::Manager.new }
+describe "AliasConstantCreator" do
+  before { @manager = Manager.new }
 
-    def create_aliases(hash, options={})
-      @manager.create_aliases(:constant, hash, options)
-    end
+  def create_aliases(hash, options={})
+    @manager.create_aliases(:constant, hash, options)
+  end
 
-    def expect_aliases(hash)
-      arr = Alias::Creators::ConstantCreator.maps_config(hash)
-      Alias::Creators::ConstantCreator.expects(:generates_aliases).with(arr).returns('')
-    end
-    
-    test "deletes existing aliases" do
-      expect_aliases "Array"=>'Ar'
-      create_aliases "Alias::Creators::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"
-    end
+  def expect_aliases(hash)
+    arr = Creators::ConstantCreator.maps_config(hash)
+    Creators::ConstantCreator.expects(:generates_aliases).with(arr).returns('')
+  end
+  
+  it "deletes existing aliases" do
+    expect_aliases "Array"=>'Ar'
+    create_aliases "Alias::Creators::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"
+  end
 
-    test "deletes existing aliases unless force option" do
-      h1 = {"Alias::Creators::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"}
-      expect_aliases h1
-      create_aliases h1, :force=>true
-    end
+  it "deletes existing aliases unless force option" do
+    h1 = {"Alias::Creators::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"}
+    expect_aliases h1
+    create_aliases h1, :force=>true
+  end
 
-    test "deletes invalid classes" do
-      eval "module ::Bling; end"
-      expect_aliases 'Array'=>'Ar'
-      create_aliases "Blah"=>"Bling", "Array"=>"Ar"
-    end
+  it "deletes invalid classes" do
+    eval "module ::Bling; end"
+    expect_aliases 'Array'=>'Ar'
+    create_aliases "Blah"=>"Bling", "Array"=>"Ar"
+  end
 
-    test "creates aliases" do
-      create_aliases 'Time'=>'T'
-      ::Time.should == ::T
-    end
+  it "creates aliases" do
+    create_aliases 'Time'=>'T'
+    ::Time.should == ::T
   end
 end

data/test/creator_test.rb

@@ -1,29 +1,25 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
-module Alias
-  class CreatorTest < Test::Unit::TestCase
-    context "invalid creator" do
-      before(:all) { eval "class Alias::TestCreator < Alias::Creator; end"}
-      test "raises AbstractMethodError if map not defined" do
-        assert_raises(Creator::AbstractMethodError) {
-          TestCreator.maps_config({})
-        }
-      end
+describe "invalid creator" do
+  before_all { eval "class Alias::TestCreator < Alias::Creator; end"}
+  it "raises AbstractMethodError if map not defined" do
+    should.raise(Creator::AbstractMethodError) {
+      TestCreator.maps_config({})
+    }
+  end
 
-      test "raises AbstractMethodError if generate not defined" do
-        assert_raises(Creator::AbstractMethodError) {
-          TestCreator.generates_aliases([])
-        }
-      end
+  it "raises AbstractMethodError if generate not defined" do
+    should.raise(Creator::AbstractMethodError) {
+      TestCreator.generates_aliases([])
+    }
+  end
 
-      test "raises ArgumentError when no validator is given" do
-        assert_raises(ArgumentError) { TestCreator.valid :name }
-      end
+  it "raises ArgumentError when no validator is given" do
+    should.raise(ArgumentError) { TestCreator.valid :name }
+  end
 
-      test "prints error and deletes validator when invalid one is given" do
-        capture_stderr { TestCreator.valid(:name, :if=>:blah) }.should =~ /not set/
-        TestCreator.validators[:name].should == nil
-      end
-    end
+  it "prints error and deletes validator when invalid one is given" do
+    capture_stderr { TestCreator.valid(:name, :if=>:blah) }.should =~ /not set/
+    TestCreator.validators[:name].should == nil
   end
-end
+end

data/test/instance_method_creator_test.rb

@@ -1,41 +1,39 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
-class Alias::Creators::InstanceMethodCreatorTest < Test::Unit::TestCase
-  context "InstanceMethodCreator" do
-    before(:each) { @manager = Alias::Manager.new }
-    def expect_aliases(hash)
-      arr = Alias::Creators::InstanceMethodCreator.maps_config(hash)
-      Alias::Creators::InstanceMethodCreator.expects(:generates_aliases).with(arr).returns('')
-    end
+describe "InstanceMethodCreator" do
+  before { @manager = Manager.new }
+  def expect_aliases(hash)
+    arr = Creators::InstanceMethodCreator.maps_config(hash)
+    Creators::InstanceMethodCreator.expects(:generates_aliases).with(arr).returns('')
+  end
 
-    def create_aliases(hash)
-      @manager.create_aliases(:instance_method, hash)
-    end
-    
-    test "deletes existing instance method aliases" do
-      expect_aliases "String"=>{"strip"=>"st"}
-      create_aliases 'String'=>{'strip'=>'st', 'chomp'=>'chop'}
-    end
+  def create_aliases(hash)
+    @manager.create_aliases(:instance_method, hash)
+  end
+  
+  it "deletes existing instance method aliases" do
+    expect_aliases "String"=>{"strip"=>"st"}
+    create_aliases 'String'=>{'strip'=>'st', 'chomp'=>'chop'}
+  end
 
-    test "deletes invalid classes" do
-      expect_aliases "String"=>{'strip','st'}
-      create_aliases "String"=>{'strip','st'}, 'Blah'=>{'map'=>'m'}
-    end
+  it "deletes invalid classes" do
+    expect_aliases "String"=>{'strip'=>'st'}
+    create_aliases "String"=>{'strip'=>'st'}, 'Blah'=>{'map'=>'m'}
+  end
 
-    test "deletes invalid instance method keys" do
-      expect_aliases "Array"=>{}, "String"=>{"strip"=>"st"}
-      create_aliases 'String'=>{'strip'=>'st'},'Array'=>{'blah', 'bl'}
-    end
+  it "deletes invalid instance method keys" do
+    expect_aliases "Array"=>{}, "String"=>{"strip"=>"st"}
+    create_aliases 'String'=>{'strip'=>'st'},'Array'=>{'blah'=>'bl'}
+  end
 
-    test "creates aliases" do
-      Kernel.eval %[
-        class ::SampleClass
-          def whoop; 'WHOOP'; end
-        end
-      ]
-      obj = SampleClass.new
-      create_aliases 'SampleClass'=>{:whoop=>:can_of_wass, :blah=>:bl}
-      SampleClass.new.whoop.should == SampleClass.new.can_of_wass
-    end
+  it "creates aliases" do
+    Kernel.eval %[
+      class ::SampleClass
+        def whoop; 'WHOOP'; end
+      end
+    ]
+    obj = SampleClass.new
+    create_aliases 'SampleClass'=>{:whoop=>:can_of_wass, :blah=>:bl}
+    SampleClass.new.whoop.should == SampleClass.new.can_of_wass
   end
 end

data/test/manager_test.rb

@@ -1,105 +1,106 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
-class Alias::ManagerTest < Test::Unit::TestCase
-    before(:each) { @manager = Alias::Manager.new}
-
-    context "create_aliases" do
-      before(:all) { eval %[class Alias::Creators::ValidTestCreator < Alias::Creator; map { [] }; generate { ' '};  end]}
-      def create_aliases(options={})
-        @manager.create_aliases :valid_test, {}, options
-      end
-
-      test "creates aliases" do
-        Kernel.expects(:eval).with(' ')
-        create_aliases
-      end
-
-      test "doesn't create aliases with pretend option" do
-        Kernel.expects(:eval).never
-        capture_stdout { create_aliases :pretend=>true }.should == "\n \n"
-      end
-
-      test "with manager's verbose sets creator's verbose" do
-        @manager.verbose = true
-        create_aliases
-        @manager.creators[:valid_test].verbose.should == true
-      end
-
-      test "with manager's verbose array sets creator's verbose" do
-        @manager.verbose = [:valid_test]
-        create_aliases
-        @manager.creators[:valid_test].verbose.should == true
-      end
-
-      test "with manager's verbose array doesn't set creator's verbose" do
-        @manager.verbose = [:another]
-        create_aliases
-        @manager.creators[:valid_test].verbose.should == false
-      end
-
-      test "with manager's force sets creator's force" do
-        @manager.force = true
-        create_aliases
-        @manager.creators[:valid_test].force.should == true
-      end
-
-      test "with manager's force array sets creator's force" do
-        @manager.force = [:valid_test]
-        create_aliases
-        @manager.creators[:valid_test].force.should == true
-      end
-
-      test "with manager's force array doesn't set creators force" do
-        @manager.force = [:another]
-        create_aliases
-        @manager.creators[:valid_test].force.should == false
-      end
-
-      test "force option sets force in creator object" do
-        create_aliases :force=>true
-        @manager.creators[:valid_test].force.should == true
-      end
-
-      test "verbose option sets verbose in creator object" do
-        create_aliases :verbose=>true
-        @manager.creators[:valid_test].verbose.should == true
-      end
-
-      test "prints error if nonexistent creator given" do
-        capture_stderr {@manager.create_aliases :blah, {} }.should =~ /not found/
-      end
-
-      test "prints error if necessary creator methods not defined" do
-        eval "class Alias::Creators::BlingCreator < Alias::Creator; end"
-        capture_stderr { @manager.create_aliases :bling, {} }.should =~ /BlingCreator/
-      end
-
-      test "prints error if aliases fail to create" do
-        eval "class Alias::Creators::Bling2Creator < Alias::Creator; map {[]}; generate { 'blah' }; end"
-        capture_stderr { @manager.create_aliases :bling2, {} }.should =~ /failed to create aliases/
-      end
-    end
-
-    context "search" do
-      before(:each) {
-        @manager.instance_variable_set "@creators", {:constant=>Alias::Creators::ConstantCreator.new}
-        @manager.stubs(:all_aliases).returns([{:name=>'Array', :alias=>'A'}, {:name=>'Abbrev', :alias=>'B'}])
-      }
-
-      test "key and symbol value" do
-        @manager.search(:name=>:Array).should == [{:name=>'Array', :alias=>'A'}]
-      end
-      
-      test "with key and string value" do
-        @manager.search(:name=>'A').should == [{:name=>'Array', :alias=>'A'}, {:name=>'Abbrev', :alias=>'B'}]
-      end
-
-      test "with a string" do
-        @manager.search('Array').should == [{:name=>'Array', :alias=>'A'}]
-      end
-
-      test "with multiple search terms" do
-        @manager.search(:name=>'A', :alias=>'A').should == [{:name=>'Array', :alias=>'A'}]
-      end
+describe "Manager" do
+  before { @manager = nil }
+  def manager; @manager ||= Manager.new; end
+
+  describe "create_aliases" do
+    before_all { eval %[class Alias::Creators::ValidTestCreator < Alias::Creator; map { [] }; generate { ' '};  end]}
+    def create_aliases(options={})
+      manager.create_aliases :valid_test, {}, options
     end
+
+    it "creates aliases" do
+      Kernel.expects(:eval).with(' ')
+      create_aliases
+    end
+
+    it "doesn't create aliases with pretend option" do
+      Kernel.expects(:eval).never
+      capture_stdout { create_aliases :pretend=>true }.should == "\n \n"
+    end
+
+    it "with manager's verbose sets creator's verbose" do
+      manager.verbose = true
+      create_aliases
+      manager.creators[:valid_test].verbose.should == true
+    end
+
+    it "with manager's verbose array sets creator's verbose" do
+      manager.verbose = [:valid_test]
+      create_aliases
+      manager.creators[:valid_test].verbose.should == true
+    end
+
+    it "with manager's verbose array doesn't set creator's verbose" do
+      manager.verbose = [:another]
+      create_aliases
+      manager.creators[:valid_test].verbose.should == false
+    end
+
+    it "with manager's force sets creator's force" do
+      manager.force = true
+      create_aliases
+      manager.creators[:valid_test].force.should == true
+    end
+
+    it "with manager's force array sets creator's force" do
+      manager.force = [:valid_test]
+      create_aliases
+      manager.creators[:valid_test].force.should == true
+    end
+
+    it "with manager's force array doesn't set creators force" do
+      manager.force = [:another]
+      create_aliases
+      manager.creators[:valid_test].force.should == false
+    end
+
+    it "force option sets force in creator object" do
+      create_aliases :force=>true
+      manager.creators[:valid_test].force.should == true
+    end
+
+    it "verbose option sets verbose in creator object" do
+      create_aliases :verbose=>true
+      manager.creators[:valid_test].verbose.should == true
+    end
+
+    it "prints error if nonexistent creator given" do
+      capture_stderr {manager.create_aliases :blah, {} }.should =~ /not found/
+    end
+
+    it "prints error if necessary creator methods not defined" do
+      eval "class Alias::Creators::BlingCreator < Alias::Creator; end"
+      capture_stderr { manager.create_aliases :bling, {} }.should =~ /BlingCreator/
+    end
+
+    it "prints error if aliases fail to create" do
+      eval "class Alias::Creators::Bling2Creator < Alias::Creator; map {[]}; generate { 'blah' }; end"
+      capture_stderr { manager.create_aliases :bling2, {} }.should =~ /failed to create aliases/
+    end
+  end
+
+  describe "search" do
+    before {
+      manager.instance_variable_set "@creators", {:constant=>Creators::ConstantCreator.new}
+      manager.stubs(:all_aliases).returns([{:name=>'Array', :alias=>'A'}, {:name=>'Abbrev', :alias=>'B'}])
+    }
+
+    it "key and symbol value" do
+      manager.search(:name=>:Array).should == [{:name=>'Array', :alias=>'A'}]
+    end
+    
+    it "with key and string value" do
+      manager.search(:name=>'A').should == [{:name=>'Array', :alias=>'A'}, {:name=>'Abbrev', :alias=>'B'}]
+    end
+
+    it "with a string" do
+      manager.search('Array').should == [{:name=>'Array', :alias=>'A'}]
+    end
+
+    it "with multiple search terms" do
+      manager.search(:name=>'A', :alias=>'A').should == [{:name=>'Array', :alias=>'A'}]
+    end
+  end
 end