alias 0.2.0

data/test/any_to_instance_method_creator_test.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::Creators::AnyToInstanceMethodCreatorTest < Test::Unit::TestCase
+  context "AnyToInstanceMethodCreator" do
+    before(:each) { @manager = Alias::Manager.new }
+
+    def expect_aliases(hash)
+      arr = Alias::Creators::AnyToInstanceMethodCreator.maps_config(hash)
+      Alias::Creators::AnyToInstanceMethodCreator.expects(:generates_aliases).with(arr).returns('')
+    end
+
+    def create_aliases(hash)
+      @manager.create_aliases(:any_to_instance_method, hash)
+    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 "creates aliases" do
+      Kernel.eval %[
+        class ::SomeClass
+          def self.cap; 'itup'; end
+        end
+        module ::SomeModule; end
+      ]
+      create_aliases 'SomeModule'=>{'SomeClass.cap.to_sym'=>'c', 'SomeClass.cap.gsub'=>'gsub'}
+      obj = Object.new.extend SomeModule
+      SomeClass.cap.to_sym.should == obj.c
+      SomeClass.cap.gsub('cap','smack') == obj.gsub('cap','smack')
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+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 }
+
+    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
+
+    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 "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
+  end
+end

data/test/creator_test.rb

@@ -0,0 +1,29 @@
+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
+
+      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

@@ -0,0 +1,105 @@
+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
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,31 @@
+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-matchy -s http://gems.github.com
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'alias'
+
+class Test::Unit::TestCase
+  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