cldwalker-alias 0.1.2 → 0.2.0

data/lib/alias/manager.rb

@@ -1,42 +1,87 @@
-# This class manages creation of aliases.
 module Alias
+  # This class manages creation, searching and saving of aliases. Aliases are created as follows:
+  # * Alias hashes are read in by Alias.create and/or input through the console via Alias::Console.create_aliases.
+  # * These alias hashes are passed to Alias::Manager.create_aliases. An Alias::Manager object passes each alias hash to 
+  #   to the correct Alias::Creator subclass by interpreting the creator type.
+  # * Each creator converts their alias hash to an alias hash array and runs them through their defined validators, Alias::Validator objects.
+  # * The aliases that meet the validation conditions are then created using Kernel.eval.
   class Manager
-  
+
     def initialize #:nodoc:
-      @alias_creators = {}
+      @creators = {}
       @verbose = false
       @force = false
     end
 
-    attr_accessor :alias_creators, :verbose, :force, :indexed_aliases
-    def alias_types; @alias_creators.keys; end
-    def alias_creator_objects; @alias_creators.values; end
-    def alias_map(type)
-      @alias_creators[type] && @alias_creators[type].alias_map
+    # When true, all failed validations print their message. Takes an array of creator type symbols or a boolean to set all creators.
+    attr_accessor :verbose
+    # When true, optional validations will be skipped. Takes an array of creator type symbols or a boolean to set all creators.
+    attr_accessor :force
+    # A hash of creator objects that have been used by creator type.
+    attr_reader :creators
+    # A hash of created aliases by creator type.
+    attr_reader :created_aliases
+
+    # The main method for creating aliases. Takes a creator type, a hash of aliases whose format is defined per creator and the
+    # following options:
+    # 
+    # [:verbose] Sets the verbose flag to print a message whenever an alias validation fails. Default is the creator's verbose flag.
+    # [:force] Sets the force flag to bypass optional validations. Default is the creator's manager flag.
+    # [:pretend] Instead of creating aliases, prints out the ruby code that would be evaluated by Kernel.eval to create the aliases.
+    #            Default is false.
+    def create_aliases(creator_type, aliases_hash, options={})
+      return unless (creator = create_creator(creator_type))
+      creator.verbose = options[:verbose] ? options[:verbose] : verbose_creator?(creator_type)
+      creator.force = options[:force] ? options[:force] : force_creator?(creator_type)
+      creator.create(aliases_hash.dup, options[:pretend] || false)
+      true
+    rescue Creator::AbstractMethodError
+      $stderr.puts $!.message
+    rescue Creator::FailedAliasCreationError
+      $stderr.puts "'#{creator.class}' failed to create aliases with error:\n#{$!.message}"
     end
-    
-    def create_creator(alias_type)
-      creator_class_string = "Alias::#{alias_type.camelize}Creator"
-      if creator_class = Object.any_const_get(creator_class_string)
-        creator_class.new
+
+    # Creates aliases in the same way as create_aliases while keeping track of what's created. But differs in that creator types can
+    # be accessed with just the first few unique letters of a type. For example, you can pass :in to mean :instance_method. Also, the
+    # verbose flag is set by default.
+    # Examples:
+    #   console_create_aliases :in, "String"=>{"to_s"=>"s"}
+    #   console_create_aliases :con, {"ActiveRecord::Base"=>"AB"}, :pretend=>true
+    def console_create_aliases(creator_type, aliases_hash, options={})
+      options = {:verbose=>true}.update(options)
+      @created_aliases ||= {}
+      creator_type = (all_creator_types.sort.find {|e| e[/^#{creator_type}/] } || creator_type).to_sym
+      if create_aliases(creator_type, aliases_hash, options)
+        @created_aliases[creator_type] = aliases_hash
+        true
       else
-        puts "Creator class '#{creator_class_string}' not found." if @verbose
-        nil
+        false
       end
-      
     end
-    
-    def create_aliases(alias_type, aliases_hash)
-      if (obj = @alias_creators[alias_type.to_sym] ||= create_creator(alias_type.to_s))
-        aliases_hash = aliases_hash.dup
-        create_options = aliases_hash.slice_off!('auto_alias', 'verbose', 'force')
-        create_options['verbose'] = @verbose unless create_options.has_key?('verbose')
-        obj.manager_create(aliases_hash, create_options)        
+
+    # Saves aliases that were created by console_create_aliases. Can take an optional file to save to. See Alias::Console.save_aliases
+    # for default files this method saves to.
+    def save_aliases(file=nil)
+      if @created_aliases
+        Alias.add_to_config_file(@created_aliases, file)
+        true
+      else
+        puts "Didn't save. No created aliases detected."
+        false
       end
     end
-    
+
+    # Searches all created alias hashes with a hash or a string. If a string, the alias key searched is :name.
+    # If a hash, the key should should be an alias key and the value the search term.
+    # All values are treated as regular expressions. Alias keys vary per creator but some of the common ones are :name, :class and :alias.
+    # Multiple keys for a hash will AND the searches.
+    # Examples:
+    #   search 'to_'
+    #   search :class=>"Array", :name=>'to'
     def search(search_hash)
       result = nil
+      reset_all_aliases
+      search_hash = {:name=>search_hash} unless search_hash.is_a?(Hash)
       search_hash.each do |k,v|
         new_result = simple_search(k,v)
         #AND's searches
@@ -44,39 +89,52 @@ module Alias
       end
       #duplicate results in case they are modified
       result = result.map {|e| e.dup} if result
-      alias_creator_objects.each {|e| e.searched_at = Time.now }
       result
     end
-    
-    def list
-      indexed_aliases.map {|e| e.dup}
+
+    # Returns an array of all created alias hashes. The alias hash will have a :type key which contains the creator type it belongs to.
+    def all_aliases
+      @all_aliases ||= @creators.inject([]) do |t, (type, creator)|
+        t += creator.aliases.each {|e| e[:type] = type.to_s}
+      end
     end
-    
+
+    #:stopdoc:
+    def all_creator_types
+      Creator.creators.map {|e| Util.underscore(e.to_s[/::(\w+)Creator$/,1]) }
+    end
+
+    def aliases_of(creator_type)
+      @creators[creator_type] && @creators[creator_type].aliases
+    end
+
+    def verbose_creator?(creator_type)
+      @verbose.is_a?(Array) ? @verbose.include?(creator_type.to_sym) : @verbose
+    end
+
+    def force_creator?(creator_type)
+      @force.is_a?(Array) ? @force.include?(creator_type.to_sym) : @force
+    end
+
+    def create_creator(creator_type)
+      creator_class_string = "Alias::Creators::#{Util.camelize(creator_type.to_s)}Creator"
+      if creator_class = Util.any_const_get(creator_class_string)
+        @creators[creator_type.to_sym] ||= creator_class.new
+      else
+        $stderr.puts "Creator class '#{creator_class_string}' not found."
+        nil
+      end
+    end
+
     def simple_search(field, search_term)
-      result = indexed_aliases.select {|e| 
-        search_term.is_a?(Regexp) ? e[field] =~ search_term : e[field] == search_term
-      }
-      result
+      all_aliases.select {|e| e[field] =~ /#{search_term}/ }
     end
     
     def intersection_of_two_arrays(arr1, arr2)
       arr2.nil? ? arr1 : arr1.select {|e| arr2.include?(e)}
     end
-    
-    def indexed_aliases(reindex=true)
-      reindex ? @indexed_aliases = reindex_aliases(@indexed_aliases) : @indexed_aliases
-    end
-        
-    def reindex_aliases(searchable_array=nil)
-      searchable_array ||= []
-      @alias_creators.map do |type, creator|
-        if creator.modified_since_last_search?
-          searchable_array.delete_if {|e| e[:type] == type.to_s}
-          new_arr = creator.to_searchable_array.each {|e| e[:type] = type.to_s}
-          searchable_array += new_arr
-        end
-      end
-      searchable_array
-    end
+
+    def reset_all_aliases; @all_aliases = nil; end
+    #:startdoc:
   end
 end

data/lib/alias/util.rb

@@ -0,0 +1,86 @@
+module Alias
+  # A collection of utility functions used throughout.
+  module Util #:nodoc:
+    extend self
+    # simplified from ActiveSupport
+    def slice(hash, *keys)
+      hash.reject {|key,| !keys.include?(key) }
+    end
+
+    def slice_off!(hash, *keys) #:nod
+      new_hash = slice(hash,*keys)
+      keys.each {|e| hash.delete(e)}
+      new_hash
+    end
+
+    #from ActiveSupport
+    def symbolize_keys(hash)
+      hash.inject({}) do |options, (key, value)|
+        options[key.to_sym] = value
+        options
+      end
+    end
+
+    # Recursively merge hash1 with hash2.
+    def recursive_hash_merge(hash1, hash2)
+      hash1.merge(hash2) {|k,o,n| (o.is_a?(Hash)) ? recursive_hash_merge(o,n) : n}
+    end
+
+    def any_const_get(name)
+      Util.const_cache[name] ||= Util.uncached_any_const_get(name)
+    end
+
+    def const_cache
+      @const_cache ||= {}
+    end
+
+    def uncached_any_const_get(name)
+      begin
+        klass = Object
+        name.split('::').each {|e|
+          klass = klass.const_get(e)
+        }
+        klass
+      rescue
+        nil
+      end
+    end
+
+    #simplified version from ActiveSupport
+    def camelize(string)
+      string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    # from ActiveSupport
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    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
+
+    def silence_warnings
+      old_verbose, $VERBOSE = $VERBOSE, nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/alias/validator.rb

@@ -0,0 +1,94 @@
+module Alias
+  # Creates validations for use with Alias::Creator.valid.
+  class Validator
+    class MissingConditionError < StandardError; end
+    class InvalidValidatorError < StandardError; end
+
+    attr_reader :validation_proc, :message
+    # Options are described in Alias::Creator.valid.
+    def initialize(options={})
+      raise ArgumentError unless options[:key] && options[:creator]
+      @condition = options[:if] || options[:unless] || raise(MissingConditionError)
+      inherits(Validator.validators[@condition]) if Validator.validators[@condition]
+      raise InvalidValidatorError unless @condition.is_a?(Proc)
+      @optional = options[:optional] || false
+      @validation_proc = options[:unless] ? lambda {|e| ! @condition.clone.call(e) } : @condition
+      @options = options
+      @message = options[:message] if options[:message]
+      @message = default_message unless @message.is_a?(Proc)
+    end
+
+    # Validates a given alias hash with the validator proc defined by :if or :unless in Alias::Creator.valid.
+    # Default arguments that these procs receive works as follows:
+    # If the validation key is the same name as any of the keys in the alias hash, then only the value of that
+    # that alias key is passed to the procs. If not, then the whole alias hash is passed.
+    def validate(current_creator, alias_hash, current_attribute)
+      return true if @optional && current_creator.force
+      arg = create_proc_arg(alias_hash, current_attribute)
+      result = !!@validation_proc.call(arg)
+      puts create_message(arg) if result != true && current_creator.verbose
+      result
+    end
+
+    #:stopdoc:
+    def inherits(parent_validator)
+      @condition = parent_validator.validation_proc.clone
+      @message = parent_validator.message.clone
+    end
+
+    def default_message
+      lambda {|e| "Validation failed for #{@options[:creator]}'s #{@options[:key]} since it doesn't exist"}
+    end
+
+    def create_proc_arg(alias_hash, current_attribute) #:nodoc:
+      @options[:with] ? @options[:with].map {|f| alias_hash[f] } : (alias_hash[current_attribute] || alias_hash)
+    end
+
+    def create_message(arg)
+      result = @message.call(arg)
+      @options[:unless] ? result.gsub("doesn't exist", 'already exists') : result
+    end
+    #:startdoc:
+
+    class <<self
+      # Hash of registered validators.
+      attr_reader :validators
+
+      # Registers validators which creators can reference as symbols in Alias::Creator.valid.
+      def register_validators(validators)
+        @validators ||= {}
+        validators.each do |e|
+          @validators[e[:key]] ||= Validator.new(e.merge(:creator=>self))
+        end
+      end
+
+      # Default validators are :constant, :class, :instance_method and :class_method.
+      def default_validators
+        [
+          {:key=>:constant, :if=>lambda {|e| any_const_get(e) }, :message=>lambda {|e| "Constant '#{e}' not created since it doesn't exist"}},
+          {:key=>:class, :if=>lambda {|e| ((klass = any_const_get(e)) && klass.is_a?(Module)) },
+            :message=>lambda {|e| "Alias for class '#{e}' not created since the class doesn't exist"}},
+          {:key=>:instance_method, :if=> lambda {|e| instance_method?(*e) },
+            :message=>lambda {|e| "Alias for instance method '#{e[0]}.#{e[1]}' not created since it doesn't exist" }},
+          {:key=>:class_method, :if=>lambda {|e| class_method?(*e) },
+            :message=>lambda {|e| "Alias for class method '#{e[0]}.#{e[1]}' not created since it doesn't exist" }}
+        ]
+      end
+
+      #:stopdoc:
+      def any_const_get(name)
+        Util.any_const_get(name)
+      end
+
+      def instance_method?(klass, method)
+        (klass = any_const_get(klass)) && (klass.method_defined?(method) || klass.private_method_defined?(method))
+      end
+
+      def class_method?(klass, method)
+        (klass = any_const_get(klass)) && klass.respond_to?(method, true)
+      end
+      #:startdoc:
+    end
+  end
+end
+Alias::Validator.register_validators(Alias::Validator.default_validators)

data/lib/alias.rb

@@ -1,51 +1,85 @@
-$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__))
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) ||
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
 require 'yaml'
-require 'config_struct'
 require 'alias/manager'
+require 'alias/validator'
 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'
+require 'alias/creators/constant_creator'
+require 'alias/creators/instance_method_creator'
+require 'alias/creators/class_method_creator'
+require 'alias/creators/class_to_instance_method_creator'
+require 'alias/creators/any_to_instance_method_creator'
+require 'alias/util'
 require 'alias/console'
 
+# Most of the core Alias actions are run through Alias::Manager except for Alias.create. 
+# See Alias::Manager for an explanation of how aliases are created.
 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
+
+  # Creates aliases from Alias.config_file if it exists and merges them with any explicit aliases. This method takes
+  # the same keys used by config files (see Alias.config_file) and also the following options:
+  # * :file : Specifies a config file to override Alias.config_file. If set to false, no config file is loaded.
+  # Examples:
+  #   # Loads any default files and the ones in :aliases. 
+  #   # Sets global verbosity for creators.
+  #   create :aliases=>{:constant=>{"Array"=>"A"}}, :verbose=>true
+  #   # Loads the given file and sets verbosity just for the :instance_method creator.
+  #   create :file=>"some file", :verbose=>[:instance_method]
+  def create(options={})
+    file_config = load_config_file(options.delete(:file))
+    new_config = Util.recursive_hash_merge(file_config, options)
+    manager.verbose = new_config[:verbose] if new_config[:verbose]
+    manager.force = new_config[:force] if new_config[:force]
+    (new_config[:aliases] || {}).each do |creator_type, aliases|
+      manager.create_aliases(creator_type, aliases)
     end
-    file ? YAML::load(File.read(file)) : {}
+    @config = Util.recursive_hash_merge(config, new_config)
   end
-  
-  def init(options={}, &block)
-    config_hash = load_config_file(options[:file])
-    config.merge! config_hash
-    config['verbose'] = options[:verbose] if !options[:verbose].nil?
-    
-    block_config = ConfigStruct.block_to_hash(block).stringify_keys
-    config.merge! block_config
-    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
+
+  # By default, looks for existing files in config/alias.yml and then ~/.alias.yml. A config file has the following keys:
+  # [:aliases] This takes a hash mapping creators to their config hashes. Valid creators are :instance_method, :class_method, :constant,
+  #            :class_to_instance_method and :any_to_instance_method.
+  # [:verbose] Sets whether creators are verbose with boolean or array of creator symbols. A boolean sets verbosity for all creators whereas
+  #            the array specifies which creators. Default is false.
+  # [:force] Sets whether creators force optional validations with boolean or array of creator symbols. Works the same as :verbose. Default is false.
+  def config_file
+    @config_file ||= File.exists?("config/alias.yml") ? 'config/alias.yml' : "#{ENV['HOME']}/.alias.yml"
+  end
+
+  # Contains primary Alias::Manager object which is used throughout Alias.
+  def manager
+    @manager ||= Manager.new
+  end
+
+  #:stopdoc:
+  def add_to_config_file(new_aliases, file)
+    file ||= File.directory?('config') ? 'config/alias.yml' : "#{ENV['HOME']}/.alias.yml"
+    existing_aliases = read_config_file(file)
+    existing_aliases[:aliases] = Util.recursive_hash_merge existing_aliases[:aliases], new_aliases
+    save_to_file file, existing_aliases.to_yaml
+    puts "Saved created aliases to #{file}."
+  end
+
+  def save_to_file(file, string)
+    File.open(File.expand_path(file), 'w') {|f| f.write string }
+  end
+
+  def read_config_file(file)
+    file_config = File.exists?(File.expand_path(file)) ? YAML::load_file(File.expand_path(file)) : {}
+    file_config = Util.symbolize_keys file_config
+    file_config[:aliases] = file_config[:aliases] ? Util.symbolize_keys(file_config.delete(:aliases)) : {}
+    file_config
+  end
+
+  def load_config_file(file)
+    return {} if file == false
+    @config_file = file if file
+    read_config_file(config_file)
   end
   
   def config
     @config ||= {}
   end
-  
-  def config=(value); @config = value; end
-    
-  def manager
-    @manager ||= Manager.new
-  end
+  #:startdoc:
 end

data/test/alias_test.rb

@@ -1,62 +1,63 @@
 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
+  context "Alias" do
+    test "loads config file config/alias.yml if found" do
+      File.expects(:exists?).with('config/alias.yml').returns(true)
+      Alias.config_file.should == 'config/alias.yml'
     end
+
+    context "create" do
+      before(:each) { Alias.instance_eval "@manager = @config = @config_file = nil"}
     
-    test "creates manager object and non-empty aliases" do
-      Alias.init :file=>File.join(File.dirname(__FILE__),'aliases.yml')
-      Alias.manager.alias_map(:instance_method)
-      Alias.manager.alias_map(:class_method)
-      Alias.manager.alias_map(:constant)
-    end
+      test "with aliases option creates aliases" do
+        options = {:aliases=>{:constant=> {'Array'=>'Arr'}, :instance_method=>{'String'=>{'to_s'=>'s'}} } , :file=>false}
+        Alias.create options
+        Alias.manager.aliases_of(:instance_method).empty?.should be(false)
+        Alias.manager.aliases_of(:constant).empty?.should be(false)
+        Alias.config.should == options
+      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 file option creates aliases" do
+        Alias.create :file=>File.join(File.dirname(__FILE__),'aliases.yml')
+        Alias.manager.aliases_of(:instance_method).empty?.should be(false)
+        Alias.manager.aliases_of(:class_method).empty?.should be(false)
+        Alias.manager.aliases_of(:constant).empty?.should be(false)
+        Alias.manager.aliases_of(:class_to_instance_method).empty?.should be(false)
+      end
+
+      test "with false file option doesn't load config file" do
+        Alias.create :file=>'blah'
+        File.expects(:exists?).never
+        Alias.create :file=>false
+      end
+
+      test "with invalid file option creates nothing" do
+        Alias.create :file=>'blah'
+        Alias.config.should == {:aliases=>{}}
+      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?
+      test "with verbose option sets manager's verbose" do
+        Alias.manager.verbose.should == false
+        Alias.create :verbose=>true, :aliases=>{}, :file=>false
+        Alias.manager.verbose.should == true
+      end
+
+      test "with force option sets manager's verbose" do
+        Alias.manager.force.should == false
+        Alias.create :force=>true, :aliases=>{}
+        Alias.manager.force.should == true
+      end
+
+      test "called twice recursively merges config" do
+        hash1 = {:constant=>{"Blah"=>"B"}}
+        Alias.manager.expects(:create_aliases).with(:constant, hash1[:constant])
+        Alias.create :aliases=>hash1, :file=>false
+        hash2 = {:constant=>{"Blah2"=>"B2"}}
+        Alias.manager.expects(:create_aliases).with(:constant, hash2[:constant])
+        Alias.create :aliases=>hash2, :file=>false
+        Alias.config.should == {:aliases=>{:constant=>{"Blah"=>"B", "Blah2"=>"B2"}} }
+      end
     end
   end
-  
-end
+end

data/test/aliases.yml

@@ -1,11 +1,15 @@
-constant:
+:aliases:
+  constant:
     Object: O
   
-class_method:
+  class_method:
     Object:
       const_get: cg
 
-instance_method:
+  instance_method:
     String:
         to_s: ts
-        bling: bl
+        bling: bl
+  class_to_instance_method:
+    String:
+      Date.civil: civ

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