cldwalker-alias 0.1.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2008 Gabriel Horner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,74 @@
+== Description
+
+Creates aliases for class methods, instance methods and constants by specifying
+them in a YAML config file. By storing your aliases, it becomes possible to easily
+share and search them. Although the default aliases are created with the irb user in mind,
+it's possible to create your own alias types. See 'Customize Alias' below.
+
+== Setup
+
+Install the gem with:
+
+    sudo gem install cldwalker-alias -s http://gems.github.com
+
+The easiest setup simply involves dropping two lines in your .irbrc:
+
+    require 'alias' 
+    Alias.init
+
+This setup assumes you have an aliases.yml in the current directory or a config/aliases.yml.
+If neither is the case, pass a :file option to init():
+
+    Alias.init :file=>"/path/to/my/clandestine_aliases.yml"
+
+If you'd like to define your aliases without a config file, pass Alias.init() a block and
+call methods as if they were top level keys in the config:
+
+    Alias.init do |a|
+      a.verbose = true
+      a.constant = {'Array' = 'A'}
+      a.instance_method = {'String'=>{'downcase'=>'dc' }, 'Array'=>{'select'=>'s'}}
+    end
+
+== Configuration
+
+For an example config file see aliases.yml.example.
+
+Options are: 
+
+* verbose : true or false
+* constant: Alias constants no matter how many levels down. Takes a hash of constants as strings,
+  mapping constants to their aliases.
+    Example: {'Date'=>'D', 'ActiveRecord::Base'=>'AB'}
+* instance_method : Alias methods for the instances of specified classes. Takes a nested hash with Ruby classes as string keys. Each class should point
+  to a hash of methods, with the original methods mapping to the alias method.
+    Example: {'String'=>{'downcase'=>'dc'}}
+* class_method : Alias class methods. Takes the same format as instance_method.
+    Example: {'Date'=>{'day_fraction_to_time'=>'dftt'}}
+ 
+== Customize Alias
+
+You can create your own alias type by creating an Alias::*Creator Class. The * is there for the alias type name.
+Suppose you want to create a my_instance_method alias type. Simply pass a my_instance_method key
+with its appropriate aliases hash in the config. Then create your my_instance_method_creator class:
+
+    module Alias
+      class MyInstanceMethodCreator < Creator
+        def create_aliases(aliases_hash)
+          # My way of aliasing
+          # ...
+        end
+      end
+    end
+
+Notice that the class should be a camelized version of the alias type and inherit from Alias::Creator.
+At a minimum, make a create_aliases() to make custom aliases from the config data.
+See creator.rb for more methods you can hook into.
+
+==  Todo
+
+* Provide an auto_alias method for creators.
+* List and search your aliases which can be easy to forget.
+* Alias/forward methods from one object to another. This will be useful for creating
+  'commands' in irb.
+* Add more RDoc documentation. 

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
+    t.verbose = true
+  end
+rescue LoadError
+  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "alias"
+    s.description = "Provides aliases for class names, class methods, instance methods and more. Mainly for console use."
+    s.email = "gabriel.horner@gmail.com"
+    s.homepage = "http://github.com/cldwalker/alias"
+    s.summary = s.description
+    s.authors = ["Gabriel Horner"]
+    s.has_rdoc = true
+    s.files = FileList["Rakefile", "README.rdoc", "LICENSE.txt", "aliases.yml.example", "{lib,test}/**/*"]
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/aliases.yml.example

@@ -0,0 +1,16 @@
+verbose: true
+constant:
+    ActiveRecord::Base: AB
+    ActionView::Base: AVB
+  
+class_method:
+    ActiveRecord::Base : 
+      connection: cn
+      find: f
+      delete: d
+
+instance_method:
+    ActiveRecord::Base :
+      update_attribute: ua
+    Array : 
+      select: s 

data/lib/alias/class_method_creator.rb

@@ -0,0 +1,9 @@
+module Alias
+  class ClassMethodCreator < Creator
+    include Alias::MethodCreatorHelper
+    
+    def method_exists?(klass, method)
+      klass.respond_to?(method)
+    end
+  end
+end

data/lib/alias/constant_creator.rb

@@ -0,0 +1,46 @@
+module Alias
+  class ConstantCreator < Creator
+    
+    def delete_invalid_aliases(aliases_hash)
+      delete_invalid_class_keys(aliases_hash)
+    end
+    
+    def delete_existing_aliases(aliases_hash)
+      aliases_hash.each do |k, v| 
+        if (klass = Object.any_const_get(v)) && ! alias_map.values.include?(v)
+          aliases_hash.delete(k)
+          puts "Alias '#{v}' deleted since the constant already exists" if self.verbose
+        end
+      end
+    end
+    
+    def create_aliases(aliases_hash)
+      eval_string = ''
+      aliases_hash.each {|k,v|
+        eval_string += "#{v} = #{k}\n"
+      }
+      Object.class_eval eval_string
+    end
+    
+    def generate_aliases(array_to_alias)
+      make_shortest_aliases(array_to_alias)
+    end
+    
+    def make_shortest_aliases(unaliased_strings)
+      shortest_aliases = {}
+      possible_alias = ''
+      unaliased_strings.each {|s|
+        possible_alias = ''
+        s.split('').each { |e|
+          possible_alias += e  
+          if ! shortest_aliases.values.include?(possible_alias)
+            shortest_aliases[s] = possible_alias
+            break
+          end
+        }
+      }
+
+      shortest_aliases
+    end
+  end
+end

data/lib/alias/core_extensions.rb

@@ -0,0 +1,52 @@
+class Hash
+  unless self.method_defined?(:slice)
+    # simplified from ActiveSupport
+    def slice(*keys)
+      reject { |key,| !keys.include?(key) }
+    end
+  end
+  
+  def slice_off!(*keys)
+    new_hash = slice(*keys)
+    keys.each {|e| self.delete(e)}
+    new_hash
+  end
+  
+  unless self.method_defined?(:stringify_keys)
+    #from ActiveSupport
+    def stringify_keys
+      inject({}) do |options, (key, value)|
+        options[key.to_s] = value
+        options
+      end
+    end
+  end
+  
+end
+
+class Object
+  def self.any_const_get(name)
+    begin
+    klass = Object
+    name.split('::').each {|e|
+      klass = klass.const_get(e)
+    }
+    klass
+    rescue; nil; end
+  end
+end
+
+class String
+  unless self.method_defined?(:camelize)
+    #simplified from ActiveSupport
+    def camelize
+      self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+  end
+end
+
+class OpenStruct
+  def to_hash
+    @table
+  end
+end

data/lib/alias/creator.rb

@@ -0,0 +1,81 @@
+# This is the base creator class from which other *Creator classes inherit.
+# Methods this class provides to non-creator classes are: Creator.create()
+# Methods this class provides to creator classes to be overridden: @creator.delete_invalid_aliases
+# and @creator.create_aliases
+
+module Alias
+  class Creator
+    
+    attr_accessor :verbose, :alias_map, :force
+    def initialize(aliases_hash={})
+      @alias_map = aliases_hash
+      @verbose = false
+      @force = false
+    end
+    
+    # Options are:
+    # * :auto_alias : Array of constants to alias by shortest available constant. For example,
+    #   if the constant A already exists, then Aardvark would be aliased to Aa.
+    def self.create(aliases_hash, options={})
+      obj = new(aliases_hash)
+      obj.verbose = options['verbose'] if options['verbose']
+      obj.force = options['force'] if options['force']
+      obj.create(obj.alias_map)
+      if options['auto_alias']
+        obj.alias_map = obj.alias_map.merge(obj.auto_create(options['auto_alias']))
+      end
+      obj
+    end
+    
+    #needs to return generated aliases_hash
+    def auto_create(array_to_alias)
+      aliases_hash = generate_aliases(array_to_alias)
+      create(aliases_hash)
+      aliases_hash
+    end
+    
+    def create(aliases_hash)
+      delete_invalid_aliases(aliases_hash)
+      delete_existing_aliases(aliases_hash) unless self.force
+      @alias_map = aliases_hash
+      #td: create method for efficiently removing constants/methods in any namespace
+      silence_warnings {
+        create_aliases(aliases_hash)
+      }
+    end
+    
+    # Should be overridden to delete aliases that point to invalid/nonexistent classes, methods ...
+    def delete_invalid_aliases(aliases_hash); end
+    
+    # Should be overridden to delete aliases that already exist. This method can be bypassed by passing
+    # a force option to the creator.
+    def delete_existing_aliases(aliases_hash); end
+    
+    # Must be overridden to use create()
+    def create_aliases(aliases_hash); 
+      raise "This abstract method must be overridden."
+    end
+    
+    # Must be overridden to use auto_create()
+    def generate_aliases(array_to_alias);
+      raise "This abstract method must be overridden."
+    end
+    
+    def delete_invalid_class_keys(klass_hash)
+      klass_hash.each {|k,v| 
+        if Object.any_const_get(k).nil?
+          puts "deleted nonexistent klass #{k} #{caller[2].split(/:/)[2]}" if self.verbose
+          klass_hash.delete(k)
+        end
+      }
+    end
+    
+    private
+    def silence_warnings
+      old_verbose, $VERBOSE = $VERBOSE, nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/alias/instance_method_creator.rb

@@ -0,0 +1,9 @@
+module Alias
+  class InstanceMethodCreator < Creator
+    include Alias::MethodCreatorHelper
+    
+    def method_exists?(klass, method)
+      klass.method_defined?(method)
+    end
+  end
+end

data/lib/alias/manager.rb

@@ -0,0 +1,40 @@
+# This class manages creation of aliases.
+module Alias
+  class Manager
+  
+    def initialize #:nodoc:
+      @alias_creators = {}
+      @verbose = false
+      @force = false
+    end
+
+    attr_accessor :alias_creators, :verbose, :force
+    def alias_types; @alias_creators.keys; end
+    
+    def factory_create_aliases(alias_type, aliases_hash)
+      creator_class_string = "Alias::#{alias_type.camelize}Creator"
+      create_options = aliases_hash.slice_off!('auto_alias', 'verbose', 'force')
+      create_options['verbose'] = @verbose unless create_options.has_key?('verbose')
+      if creator_class = Object.any_const_get(creator_class_string)
+        creator_class.create(aliases_hash, create_options)
+      else
+        puts "Creator class '#{creator_class_string}' not found." if @verbose
+        nil
+      end
+    end
+    
+    def create_aliases(alias_type, aliases_hash)
+      aliases_hash = aliases_hash.dup
+      if obj = factory_create_aliases(alias_type.to_s, aliases_hash.dup)
+        @alias_creators[alias_type.to_sym] ||= obj
+        
+        accessor_method = "#{alias_type}_aliases"
+        if ! respond_to?(accessor_method)
+          self.class.send :attr_accessor, accessor_method
+        end
+        self.send("#{accessor_method}=", {}) if self.send(accessor_method).nil?
+        self.send(accessor_method).merge! obj.alias_map
+      end
+    end
+  end
+end

data/lib/alias/method_creator_helper.rb

@@ -0,0 +1,69 @@
+module Alias
+  module MethodCreatorHelper
+    def delete_invalid_aliases(aliases_hash)
+      delete_invalid_class_keys(aliases_hash)
+      delete_invalid_method_keys(aliases_hash)
+    end
+    
+    def delete_existing_aliases(aliases_hash)
+      delete_existing_method_aliases(aliases_hash)
+    end
+    
+    def create_aliases(aliases_hash)
+      create_method_aliases(aliases_hash)
+    end
+    
+    def method_exists?(klass, method)
+      raise "This abstract method must be overridden."
+    end
+    
+    def delete_invalid_method_keys(alias_hash)
+      alias_hash.each do |k, methods|
+        if klass = Object.any_const_get(k)
+          methods.keys.each do |e|
+            if ! method_exists?(klass,e)
+              methods.delete(e)
+              puts "#{klass}: alias to method '#{e}' deleted since it doesn't exist" if self.verbose
+            end
+          end
+        end
+      end
+    end
+    
+    def delete_existing_method_aliases(aliases_hash)
+      aliases_hash.each do |k, methods_hash|
+        if klass = Object.any_const_get(k)
+          methods_hash.each do |a,b|
+            if method_exists?(klass,b) && !(alias_map[k].is_a?(Hash) && alias_map[k].values.include?(b))
+              methods_hash.delete(a)
+              puts "#{klass}: alias '#{b}' deleted since the method already exists" if self.verbose
+            end
+          end
+        end
+      end
+    end
+    
+    def create_method_aliases_per_class(klass, alias_hash)
+      eval_string = ""
+      alias_hash.each {|original_method, alias_methods|
+        alias_methods = [alias_methods] unless alias_methods.is_a?(Array)
+        alias_methods.each { |a|
+          eval_string += "alias_method :#{a}, :#{original_method}\n"
+        }
+      }
+      if self.is_a?(ClassMethodCreator)
+        eval_string = "class <<self\n #{eval_string}\nend"
+      end
+      klass.class_eval eval_string
+    end
+    
+    def create_method_aliases(aliases)
+      aliases ||= {}
+      aliases.each { |k,alias_hash|
+        if klass = Object.any_const_get(k)
+          create_method_aliases_per_class(klass, alias_hash)
+        end
+      }
+    end      
+  end
+end

data/lib/alias.rb

@@ -0,0 +1,55 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__))
+require 'yaml'
+require 'ostruct'
+require 'alias/manager'
+require 'alias/creator'
+require 'alias/constant_creator'
+require 'alias/method_creator_helper'
+require 'alias/instance_method_creator'
+require 'alias/class_method_creator'
+require 'alias/core_extensions'
+
+module Alias
+  extend self
+  
+  def load_config_file(file=nil)
+    if file.nil?
+      if File.exists?("config/aliases.yml")
+        file = "config/aliases.yml"
+      elsif File.exists?("aliases.yml")
+        file = "aliases.yml"
+      end
+    end
+    file ? YAML::load(File.read(file)) : {}
+  end
+  
+  def init(options={})
+    config_hash = load_config_file(options[:file])
+    config.merge! config_hash
+    config['verbose'] = options[:verbose] if !options[:verbose].nil?
+    
+    if block_given?
+      obj = OpenStruct.new
+      yield(obj)
+      block_config = obj.to_hash.stringify_keys
+      config.merge! block_config
+    end
+    
+    manager.verbose = config['verbose'] if config.has_key?('verbose')
+    config.each do |k,v|
+      next if ['verbose'].include?(k)
+      manager.create_aliases(k, v)
+    end
+    self
+  end
+  
+  def config
+    @config ||= {}
+  end
+  
+  def config=(value); @config = value; end
+    
+  def manager
+    @manager ||= Manager.new
+  end
+end

data/test/alias_test.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class AliasTest < Test::Unit::TestCase
+  test "loads config file config/aliases.yml if found" do
+    File.expects(:exists?).with('config/aliases.yml').returns(true)
+    File.expects(:read).returns('')
+    Alias.load_config_file
+  end
+  
+  test "loads config file aliases.yml if found" do
+    File.stubs(:exists?).returns(false, true)
+    File.stubs(:read).returns('')
+    Alias.load_config_file
+  end
+  
+  test "loads given config file" do
+    config = Alias.load_config_file(File.join(File.dirname(__FILE__),'aliases.yml'))
+    assert config.is_a?(Hash)
+  end
+  
+  test "returns hash if no config file found" do
+    File.stubs(:exists?).returns(false)
+    Alias.load_config_file.should == {}
+  end
+  
+  context "Alias_init" do
+    before(:each) { Alias.config = {}}
+    
+    test "with block sets config properly" do
+      Alias.manager.expects(:create_aliases).times(2)
+      Alias.init do |a|
+        a.verbose = true
+        a.constant = {'Blah'=>'B'}
+        a.instance_method = {'String'=>{'to_s'=>'s'}}
+      end
+      expected_config = {"instance_method"=>{"String"=>{"to_s"=>"s"}}, "constant"=>{"Blah"=>"B"}, "verbose"=>true}
+      Alias.config.should == expected_config
+    end
+    
+    test "creates manager object and non-empty aliases" do
+      Alias.init :file=>File.join(File.dirname(__FILE__),'aliases.yml')
+      Alias.manager.instance_method_aliases.empty?.should_not be(true)
+      Alias.manager.class_method_aliases.empty?.should_not be(true)
+      Alias.manager.constant_aliases.empty?.should_not be(true)
+    end
+    
+    test "with verbose option sets config and manager verbosity" do
+      Alias.manager.stubs(:create_aliases)
+      Alias.init :verbose=>true
+      assert Alias.config['verbose']
+      assert Alias.manager.verbose
+    end
+    
+    test "with no verbose option doesn't set config and manager verbosity" do
+      Alias.manager.stubs(:create_aliases)
+      assert Alias.manager.expects(:verbose=).never
+      Alias.init
+      assert Alias.config['verbose'].nil?
+    end
+  end
+  
+end

data/test/aliases.yml

@@ -0,0 +1,11 @@
+constant:
+    Object: O
+  
+class_method:
+    Object:
+      const_get: cg
+
+instance_method:
+    String:
+        to_s: ts
+        bling: bl

data/test/core_extensions_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::CoreExtensionsTest < Test::Unit::TestCase
+  test "any_const_get fetches simple class" do
+    Object.any_const_get("Array").should == Array
+  end
+  
+  test "any_const_get fetches nested class" do
+    eval "module ::Somemodule; class Someclass; end; end"
+    Object.any_const_get("Somemodule::Someclass").should == Somemodule::Someclass
+  end
+  
+  test "any_const_get returns nil for nonexistent class" do
+    Object.any_const_get("NonexistentClass").should == nil
+  end
+  
+  test "slice only returns valid keys given" do
+    {:a=>1, :b=>2}.slice(:a, :c).should == {:a=>1}
+  end
+  
+  test "slice_off! returns given keys but takes them off existing hash" do
+    h = {:a=>1, :b=>2}
+    h.slice_off!(:a, :c).should == {:a=>1}
+    h.should == {:b=>2}
+  end
+  
+  test "camelize should uppercase non-underscored string" do
+    'man'.camelize.should == 'Man'
+  end
+  
+  test "camelize should camelize underscored string" do
+    'some_test'.camelize.should == 'SomeTest'
+  end
+end

data/test/creator_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::CreatorTest < Test::Unit::TestCase
+  context "AliasConstantCreator" do
+    before(:each) { @creator = Alias::ConstantCreator.new}
+    
+    test "deletes existing aliases" do
+      h1 = {"Alias::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"}
+      @creator.delete_existing_aliases(h1)
+      h1.should == {"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
+    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
+    end   
+  end
+  
+  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  
+end

data/test/manager_test.rb

@@ -0,0 +1,52 @@
+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'}
+      @manager.verbose = true
+      @manager.create_aliases(:constant, h1)
+      assert @manager.alias_creators[:constant].verbose
+    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.constant_aliases.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.instance_method_aliases.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.class_method_aliases
+      SampleClass.capohow.should == SampleClass.cap
+    end
+    end
+  
+end

data/test/method_creator_helper_test.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::MethodCreatorHelperTest < Test::Unit::TestCase
+  
+  context "ClassMethodCreator" do
+    before(:each) { @creator = Alias::ClassMethodCreator.new }
+    
+    test "deletes invalid class method keys" do
+      h1 = {'String'=>{'yaml_new'=>'yn'},'Array'=>{'blah'=>'bl'}}
+      @creator.delete_invalid_method_keys(h1)
+      h1.should == {"Array"=>{}, "String"=>{'yaml_new'=>'yn'}}
+    end
+  
+    test "deletes existing class method aliases" do
+      h1 = {'Date'=>{'civil_to_jd'=>'civil', 'valid_time?'=>'vt'} }
+      @creator.delete_existing_method_aliases(h1)
+      h1.should == {'Date'=>{'valid_time?'=>'vt'} }
+    end
+  
+    test "deletes existing class method unless it was created by the object" do
+      h1 = {'String'=>{'name'=>'n'}}
+      @creator.create(h1)
+      assert_not_equal 'blah', String.n
+      h2 = {'String'=>{'new'=>'n'}}
+      @creator.create(h2)
+      assert_equal 'blah', String.n('blah')
+    end
+  end
+  
+  context "InstanceMethodCreator" do
+    before(:each) { @creator = Alias::InstanceMethodCreator.new }
+    
+    test "deletes existing instance method aliases" do
+      h1 = {'String'=>{'strip'=>'st', 'chomp'=>'chop'}}
+      @creator.delete_existing_method_aliases(h1)
+      h1.should == {"String"=>{"strip"=>"st"}}
+    end
+    
+    test "deletes existing instance method unless it was created by the object" do
+      h1 = {'String'=>{'downcase'=>'d'}}
+      @creator.create(h1)
+      assert_not_equal 'bh', 'blah'.d
+      h2 = {'String'=>{'delete'=>'d'}}
+      @creator.create(h2)
+      assert_equal 'bh', 'blah'.d('la')
+    end
+  
+    test "deletes invalid instance method keys" do
+      h1 = {'String'=>{'strip'=>'st'},'Array'=>{'blah', 'bl'}}
+      @creator.delete_invalid_method_keys(h1)
+      h1.should == {"Array"=>{}, "String"=>{"strip"=>"st"}}
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+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'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'alias'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: cldwalker-alias
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Gabriel Horner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-20 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Provides aliases for class names, class methods, instance methods and more. Mainly for console use.
+email: gabriel.horner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.rdoc
+- LICENSE.txt
+- aliases.yml.example
+- lib/alias
+- lib/alias/class_method_creator.rb
+- lib/alias/constant_creator.rb
+- lib/alias/core_extensions.rb
+- lib/alias/creator.rb
+- lib/alias/instance_method_creator.rb
+- lib/alias/manager.rb
+- lib/alias/method_creator_helper.rb
+- lib/alias.rb
+- test/alias_test.rb
+- test/aliases.yml
+- test/core_extensions_test.rb
+- test/creator_test.rb
+- test/manager_test.rb
+- test/method_creator_helper_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/cldwalker/alias
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Provides aliases for class names, class methods, instance methods and more. Mainly for console use.
+test_files: []
+