cldwalker-alias 0.1.2 → 0.2.0

data/test/class_method_creator_test.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::Creators::ClassMethodCreatorTest < Test::Unit::TestCase
+  
+  context "ClassMethodCreator" do
+    before(:each) { @manager = Alias::Manager.new }
+    def expect_aliases(hash)
+      arr = Alias::Creators::ClassMethodCreator.maps_config(hash)
+      Alias::Creators::ClassMethodCreator.expects(:generates_aliases).with(arr).returns('')
+    end
+
+    def create_aliases(hash)
+      @manager.create_aliases(:class_method, hash)
+    end
+    
+    test "deletes invalid class method keys" do
+      expect_aliases "Array"=>{}, "String"=>{'yaml_new'=>'yn'}
+      create_aliases 'String'=>{'yaml_new'=>'yn'},'Array'=>{'blah'=>'bl'}
+    end
+  
+    test "deletes invalid classes" do
+      expect_aliases "String"=>{'yaml_new'=>'yn'}
+      create_aliases 'String'=>{'yaml_new'=>'yn'},'Blah'=>{'new'=>'n'}
+    end
+
+    test "deletes existing class method aliases" do
+      expect_aliases 'Date'=>{'valid_time?'=>'vt'}
+      create_aliases 'Date'=>{'civil_to_jd'=>'civil', 'valid_time?'=>'vt'}
+    end
+
+    test "creates class method aliases" do
+      Kernel.eval %[
+        class ::SampleClass
+          def self.cap; 'itup'; end
+        end
+      ]
+      hash1 = {'SampleClass'=>{:cap=>:capohow}, 'Array'=>{:blah=>:bl}}
+      @manager.create_aliases(:class_method, hash1)
+      SampleClass.capohow.should == SampleClass.cap
+    end
+  end
+end

data/test/class_to_instance_method_creator_test.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::Creators::ClassToInstanceMethodCreatorTest < Test::Unit::TestCase
+  context "ClassToInstanceMethodCreator" do
+    before(:each) { @manager = Alias::Manager.new }
+
+    def expect_aliases(hash)
+      arr = Alias::Creators::ClassToInstanceMethodCreator.maps_config(hash)
+      Alias::Creators::ClassToInstanceMethodCreator.expects(:generates_aliases).with(arr).returns('')
+    end
+
+    def create_aliases(hash)
+      @manager.create_aliases(:class_to_instance_method, hash)
+    end
+
+    test "deletes invalid to classes" do
+      expect_aliases 'String'=>{'String.to_s'=>'s'}
+      create_aliases 'String'=>{'AnotherString.name'=>'n', 'String.to_s'=>'s'}
+    end
+
+    test "deletes invalid classes" do
+      expect_aliases 'String'=>{'String.to_s'=>'s'}
+      create_aliases 'String'=>{'String.to_s'=>'s'}, 'AnotherString'=>{'String.to_s'=>'s'}
+    end
+
+    test "deletes existing method aliases" do
+      expect_aliases 'String'=>{'Date.commercial'=>'s'}
+      create_aliases 'String'=>{'Date.civil'=>'strip', 'Date.commercial'=>'s'}
+    end
+
+    test "deletes invalid to methods" do
+      expect_aliases 'String'=>{'Date.civil'=>'c'}
+      create_aliases 'String'=>{'Date.civil'=>'c', 'Date.uncivil'=>'uc'}
+    end
+
+    test "creates aliases" do
+      Kernel.eval %[
+        class ::SampleClass
+          def self.cap; 'itup'; end
+        end
+        module ::SampleModule; end
+      ]
+      create_aliases 'SampleModule'=>{'SampleClass.cap'=>'c', 'Sampleclass.dap'=>'d'}
+      obj = Object.new.extend SampleModule
+      SampleClass.cap.should == obj.c
+    end
+  end
+end

data/test/console_test.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::ConsoleTest < Test::Unit::TestCase
+  before(:all) { @console = Object.new.extend(Alias::Console) }
+
+  test "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
+    Alias.manager.expects(:create_aliases).with(:instance_method, {}, anything)
+    @console.create_aliases(:in, {})
+  end
+
+  test "search_aliases lists aliases if given nothing" do
+    Alias.manager.expects(:all_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") }
+
+    test "saves created aliases" do
+      hash = {"Bluh"=>{"blah"=>"bl"}}
+      @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/
+    end
+
+    test "saves to given file" do
+      hash = {"Bluh"=>{"blah"=>"b"}}
+      @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/
+    end
+
+    test "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
+      File.expects(:directory?).returns(true)
+      @console.create_aliases :instance_method, {"Bluh"=>{"blah"=>"b2"}}
+      Alias.expects(:save_to_file).with("config/alias.yml", anything)
+      capture_stdout { @console.save_aliases }
+    end
+
+    test "merges existing aliases with created aliases" do
+      hash = {"Bluh"=>{"blah"=>"b3"}}
+      @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 }
+    end
+  end
+end

data/test/constant_creator_test.rb

@@ -1,33 +1,38 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
-class Alias::ConstantCreatorTest < Test::Unit::TestCase
+class Alias::Creators::ConstantCreatorTest < Test::Unit::TestCase
   context "AliasConstantCreator" do
-    before(:each) { @creator = Alias::ConstantCreator.new}
+    before(:each) { @manager = Alias::Manager.new }
+
+    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
-      h1 = {"Alias::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"}
-      @creator.delete_existing_aliases(h1)
-      h1.should == {"Array"=>"Ar"}
+      expect_aliases "Array"=>'Ar'
+      create_aliases "Alias::Creators::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"
     end
-    
-    test "deletes existing alias unless it was created by the object" do
-      h1 = {"Array"=>"A"}
-      @creator.create(h1)
-      assert_not_equal A, ArgumentError
-      h2 = {"ArgumentError"=>"A"}
-      @creator.create(h2)
-      assert_equal A, ArgumentError
+
+    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
-    
-    test "makes shortest aliases" do
-      eval "::Y = 'some value'"
-      expected_hash = {"Yo"=>"Y", "Man"=>"M", "Cool"=>"C", 'Yay'=>'Ya'}
-      @creator.make_shortest_aliases(['Yo','Yay','Cool','Man']).should == expected_hash
+
+    test "deletes invalid classes" do
+      eval "module ::Bling; end"
+      expect_aliases 'Array'=>'Ar'
+      create_aliases "Blah"=>"Bling", "Array"=>"Ar"
     end
-    
-    test "to_searchable_array is an array of hashes" do
-      @creator.alias_map = {'Alias'=>'A'}
-      @creator.to_searchable_array.should == [{:name=>'Alias', :alias=>'A'}]
+
+    test "creates aliases" do
+      create_aliases 'Time'=>'T'
+      ::Time.should == ::T
     end
   end
 end

data/test/creator_test.rb

@@ -1,70 +1,29 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
-class Alias::CreatorTest < Test::Unit::TestCase
-  test "Creator deletes invalid class keys" do
-    h1 = {'Alias::Creator'=>'whoop','Yay'=>'Haha'}
-    @creator = Alias::Creator.new
-    @creator.delete_invalid_class_keys(h1)
-    h1.should == {'Alias::Creator'=>'whoop'}
-  end
-  
-  context "Creator" do
-    before(:each) { @creator = Alias::Creator.new}
-    test "calls delete_existing_aliases when no force" do
-      @creator.force = false
-      @creator.expects(:delete_existing_aliases)
-      @creator.expects(:create_aliases)
-      @creator.create({})
-    end
-    
-    test "doesn't call delete_existing_aliases when force" do
-      @creator.force = true
-      @creator.expects(:delete_existing_aliases).never
-      @creator.expects(:create_aliases)
-      @creator.create({})
-    end
-    
-    test "sets modified_at timestamp when creating aliases" do
-      stub_time = Time.new
-      Time.expects(:now).returns(stub_time)
-      @creator.expects(:create_aliases)
-      @creator.create({})
-      @creator.modified_at.should == stub_time
-    end
-    
-    test "with modified_at > searched_at has been modified_since_last_search?" do
-      some_time = Time.new
-      @creator.modified_at = some_time + 100
-      @creator.searched_at = some_time
-      assert @creator.modified_since_last_search?
-    end
-    
-    test "with modified_at greater than searched_at has been modified_since_last_search?" do
-      some_time = Time.new
-      @creator.modified_at = some_time + 100
-      @creator.searched_at = some_time
-      assert @creator.modified_since_last_search?
-    end
-    
-    test "with modified_at less than searched_at has not been modified_since_last_search?" do
-      some_time = Time.new
-      @creator.modified_at = some_time
-      @creator.searched_at = some_time + 100
-      assert !@creator.modified_since_last_search?
-    end
-    
-    test "with no searched_at has been modified_since_last_search?" do
-      @creator.modified_at = Time.new
-      @creator.searched_at = nil
-      assert @creator.modified_since_last_search?
-    end
-    
-    test "sets modified_at when calling alias_map=" do
-      stub_time = Time.new
-      Time.expects(:now).returns(stub_time)
-      @creator.alias_map = {'blah'=>'b'}
-      @creator.modified_at.should == stub_time
+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
+
+      test "raises AbstractMethodError if generate not defined" do
+        assert_raises(Creator::AbstractMethodError) {
+          TestCreator.generates_aliases([])
+        }
+      end
+
+      test "raises ArgumentError when no validator is given" do
+        assert_raises(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
-    
   end
 end

data/test/instance_method_creator_test.rb

@@ -0,0 +1,41 @@
+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
+
+    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
+
+    test "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
+
+    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
+  end
+end

data/test/manager_test.rb

@@ -2,109 +2,104 @@ require File.join(File.dirname(__FILE__), 'test_helper.rb')
 
 class Alias::ManagerTest < Test::Unit::TestCase
     before(:each) { @manager = Alias::Manager.new}
-    
-    context "Manager" do
-      test "verbosity trickles down to creator objects" do
-        h1 = {'String'=>'Strang'}
+
+    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
-        @manager.create_aliases(:constant, h1)
-        assert @manager.alias_creators[:constant].verbose
+        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
-        h1 = {'force'=>true}
-        @manager.create_aliases(:constant, h1)
-        assert @manager.alias_creators[:constant].force
-      end
-    
-      test "creates constant aliases" do
-        h1 = {'Time'=>'T', 'auto_alias'=>['Date']}
-        @manager.create_aliases(:constant, h1)
-        @manager.alias_map(:constant).should == {'Time'=>'T', 'Date'=>'D'}
-      end
-    
-      test "creates instance method aliases" do
-        Kernel.eval %[
-          class ::SampleClass
-            def whoop; 'WHOOP'; end
-          end
-        ]
-        obj = SampleClass.new
-        @manager.create_aliases(:instance_method, {'SampleClass'=>{:whoop=>:can_of_wass, :blah=>:bl}})
-        @manager.alias_map(:instance_method).should == {'SampleClass'=>{:whoop=>:can_of_wass}}
-        SampleClass.new.whoop.should == SampleClass.new.can_of_wass
-      end
-    
-      test "creates class method aliases" do
-        Kernel.eval %[
-          class ::SampleClass
-            def self.cap; 'itup'; end
-          end
-        ]
-        hash1 = {'SampleClass'=>{:cap=>:capohow}, 'Array'=>{:blah=>:bl}}
-        @manager.create_aliases(:class_method, hash1)
-        expected_result = {"SampleClass"=>{:cap=>:capohow}, "Array"=>{}}
-        assert_equal expected_result, @manager.alias_map(:class_method)
-        SampleClass.capohow.should == SampleClass.cap
+        create_aliases :force=>true
+        @manager.creators[:valid_test].force.should == true
       end
-      
-      context "search" do
-        def setup_search
-          @manager.alias_creators = {:constant=>Alias::ConstantCreator.new}
-          @manager.expects(:indexed_aliases).returns([{:name=>'Array', :alias=>'A'}, {:name=>'Abbrev', :alias=>'Ab'}])
-        end
-        
-        test "sets creator's searched_at" do
-          setup_search
-          assert @manager.alias_creators[:constant].searched_at.nil? 
-          @manager.search :name=>'blah'
-          assert @manager.alias_creators[:constant].searched_at.is_a?(Time)
-        end
-        
-        test "with string returns exact match" do
-          setup_search
-          @manager.search(:name=>'Array').should == [{:name=>'Array', :alias=>'A'}]
-        end
-        
-        test "with regex returns multiple matches " do
-          setup_search
-          @manager.search(:name=>/A/).should == [{:name=>'Array', :alias=>'A'}, {:name=>'Abbrev', :alias=>'Ab'}]
-        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
       
-      context "when indexing search" do
-        def setup_index
-          @creator = Alias::ConstantCreator.new
-          @creator.alias_map = {'Array'=>'A', 'Abbrev'=>'Ab'}
-          @manager.alias_creators = {:constant=>@creator}
-        end
-        
-        test "works when first initialized" do
-          setup_index
-          @creator.stubs(:modified_since_last_search?).returns(true)
-          expected_result = [{:type=>"constant", :name=>"Array", :alias=>"A"}, {:type=>"constant", :name=>"Abbrev", :alias=>"Ab"}]
-          assert @manager.indexed_aliases(false).nil?
-          @manager.indexed_aliases.should == expected_result
-        end
-        
-        test "with modified creator, deletes old + adds new aliases" do
-          original_aliases = [{:type=>"constant", :name=>"Enumerable", :alias=>"E"}]
-          @manager.indexed_aliases = original_aliases
-          setup_index
-          @creator.stubs(:modified_since_last_search?).returns(true)
-          expected_result = [{:type=>"constant", :name=>"Array", :alias=>"A"}, {:type=>"constant", :name=>"Abbrev", :alias=>"Ab"}]
-          assert @manager.indexed_aliases(false).include?(original_aliases[0])
-          @manager.indexed_aliases.should == expected_result
-          assert !@manager.indexed_aliases.include?(original_aliases[0])
-        end
-        
-        test "with unmodified creator, doesn't change any aliases" do
-          setup_index
-          @manager.indexed_aliases = [{:type=>"constant", :name=>"Enumerable", :alias=>"E"}]
-          @creator.stubs(:modified_since_last_search?).returns(false)
-          @manager.indexed_aliases.should ==  [{:type=>"constant", :name=>"Enumerable", :alias=>"E"}]
-        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
     end
-    
 end

data/test/test_helper.rb

@@ -2,10 +2,30 @@ require 'rubygems'
 require 'test/unit'
 require 'context' #gem install jeremymcanally-context -s http://gems.github.com
 require 'mocha' #gem install mocha
-require 'matchy' #gem install jeremymcanally-stump -s http://gems.github.com
-require 'pending'
+require 'matchy' #gem install jeremymcanally-matchy -s http://gems.github.com
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'alias'
 
 class Test::Unit::TestCase
-end
+  def capture_stdout(&block)
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    fake.string
+  end
+
+  def capture_stderr(&block)
+    original_stderr = $stderr
+    $stderr = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stderr = original_stderr
+    end
+    fake.string
+  end
+end

data/test/util_test.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+module Alias
+  class UtilTest < Test::Unit::TestCase
+    test "any_const_get fetches simple class" do
+      Util.any_const_get("Array").should == Array
+    end
+  
+    test "any_const_get fetches nested class" do
+      eval "module ::Somemodule; class Someclass; end; end"
+      Util.any_const_get("Somemodule::Someclass").should == Somemodule::Someclass
+    end
+  
+    test "any_const_get returns nil for nonexistent class" do
+      Util.any_const_get("NonexistentClass").should == nil
+    end
+  
+    test "slice only returns valid keys given" do
+      Util.slice({:a=>1,:b=>2}, :a, :c).should == {:a=>1}
+    end
+  
+    test "slice_off! returns given keys but takes them off existing hash" do
+      h = {:a=>1, :b=>2}
+      Util.slice_off!(h, :a, :c).should == {:a=>1}
+      h.should == {:b=>2}
+    end
+  
+    test "camelize should uppercase non-underscored string" do
+      Util.camelize('man').should == 'Man'
+    end
+  
+    test "camelize should camelize underscored string" do
+      Util.camelize('some_test').should == 'SomeTest'
+    end
+
+    test "make_shortest_aliases" do
+      eval "::Y = 'some value'"
+      expected_hash = {"Yo"=>"Y", "Man"=>"M", "Cool"=>"C", 'Yay'=>'Ya'}
+      Util.make_shortest_aliases(['Yo','Yay','Cool','Man']).should == expected_hash
+    end
+  end
+end