cldwalker-alias 0.1.1 → 0.1.2

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT LICENSE
 
-Copyright (c) 2008 Gabriel Horner
+Copyright (c) 2009 Gabriel Horner
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -30,6 +30,41 @@ call methods as if they were top level keys in the config:
       a.instance_method = {'String'=>{'downcase'=>'dc' }, 'Array'=>{'select'=>'s'}}
     end
 
+== Irb/Console Use
+
+To use in irb or your own console, simply include the console class:
+
+    irb>>include Alias::Console
+    => Object
+
+Currently only two methods are imported: search and create.
+Search lists your aliases and create, well, creates aliases.
+
+Create:
+  
+    irb>>create :constant, "Alias"=>"A"
+    =>nil
+
+    irb>>A
+    =>Alias
+  
+Search:
+    
+    # Searches all alias types for an Alias
+    irb>>search :alias=>'A'
+    A = Alias (type: constant)
+
+    #Searches all alias types for any aliases with an A
+    irb>>search :alias=>/A/
+    A = Alias (type: constant)
+    AB = ActiveRecord::Base (type: constant)
+
+    #Searches only class_method types named 'find'
+    irb>>search :type=>'class_method', :name=>'find'
+    [] = find (type: class_method, class: ActiveRecord::Base)
+  
+
+
 == Configuration
 
 For an example config file see aliases.yml.example.
@@ -67,8 +102,8 @@ 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.
+* Provide an auto_alias method for creators.
+* Save aliases to file (for console use).
 * Add more RDoc documentation. 

data/Rakefile

@@ -24,7 +24,8 @@ begin
     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}/**/*"]
+    s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+    s.files = FileList["Rakefile", "VERSION.yml", "README.rdoc", "LICENSE.txt", "aliases.yml.example", "{lib,test}/**/*"]
   end
 
 rescue LoadError

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 2

data/lib/alias/console.rb

@@ -0,0 +1,56 @@
+#Usage: include Alias::Console wherever you want to use these methods
+module Alias
+  module Console
+    def self.included(base)
+      base.extend self
+    end
+    
+    def create(*args)
+      Alias.manager.create_aliases(*args)
+    end
+    
+    #options: type, raw, class, sort
+    #s 'man', :type=>'instance_method'
+    #s /ma/, :raw=>true
+    def search(*args)
+      options = args[-1].is_a?(Hash) ? args[-1].slice_off!(:raw, :sort) : {}
+      if args[0] && ! (args[0].is_a?(Hash) && args[0].empty?)
+        if args[0].is_a?(String) or args[0].is_a?(Regexp)
+          search_hash = {:name=>args[0]}
+          search_hash.merge!(args[1]) if args[1].is_a?(Hash)
+        elsif args[0].is_a?(Hash)
+          search_hash = args[0]
+        end
+        result = Alias.manager.search(search_hash)
+      else
+        result = Alias.manager.list
+      end
+      
+      if options[:sort]
+        result = result.sort {|a,b| 
+          (a[options[:sort]].nil? || b[options[:sort]].nil?) ? 1 :
+            (a[options[:sort]]) <=> b[options[:sort]]
+        }
+      end
+      if options[:raw]
+        result
+      else
+        format_search(result, options)
+        nil
+      end
+    end
+    
+    def format_search(result, options)
+      body = ''
+      if result.empty?
+        body = "No results"
+      else
+        result.each do |e|
+          h = e.slice_off!(:name, :alias)
+          body += "#{h[:alias]} = #{h[:name]}  (" + e.map {|k,v| "#{k}: #{v}"}.join(", ") + ")\n" 
+        end
+      end
+      puts body
+    end    
+  end
+end

data/lib/alias/constant_creator.rb

@@ -26,6 +26,10 @@ module Alias
       make_shortest_aliases(array_to_alias)
     end
     
+    def to_searchable_array
+      @alias_map.map {|k,v| {:name=>k, :alias=>v}}
+    end
+    
     def make_shortest_aliases(unaliased_strings)
       shortest_aliases = {}
       possible_alias = ''

data/lib/alias/core_extensions.rb

@@ -43,10 +43,4 @@ class String
       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

@@ -6,38 +6,45 @@
 module Alias
   class Creator
     
-    attr_accessor :verbose, :alias_map, :force
+    attr_accessor :verbose, :force, :searched_at, :modified_at, :alias_map
     def initialize(aliases_hash={})
-      @alias_map = aliases_hash
+      self.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
+    def modified_since_last_search?
+      (@searched_at && @modified_at) ? (@modified_at > @searched_at) : true
+    end
+    
+    def alias_map=(value)
+      @modified_at = Time.now
+      @alias_map = value
     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
     
+    # 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 manager_create(aliases_hash, options = {})
+      self.verbose = options['verbose'] if options['verbose']
+      self.force = options['force'] if options['force']
+      create(aliases_hash)
+      if options['auto_alias']
+        auto_create(options['auto_alias'])
+      end
+    end
+    
     def create(aliases_hash)
       delete_invalid_aliases(aliases_hash)
       delete_existing_aliases(aliases_hash) unless self.force
-      @alias_map = aliases_hash
+      self.alias_map = alias_map.merge aliases_hash
+      
       #td: create method for efficiently removing constants/methods in any namespace
       silence_warnings {
         create_aliases(aliases_hash)
@@ -61,6 +68,9 @@ module Alias
       raise "This abstract method must be overridden."
     end
     
+    #Should be overridden to support search
+    def to_searchable_array; []; end
+    
     def delete_invalid_class_keys(klass_hash)
       klass_hash.each {|k,v| 
         if Object.any_const_get(k).nil?

data/lib/alias/manager.rb

@@ -8,33 +8,75 @@ module Alias
       @force = false
     end
 
-    attr_accessor :alias_creators, :verbose, :force
+    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
+    end
     
-    def factory_create_aliases(alias_type, aliases_hash)
+    def create_creator(alias_type)
       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)
+        creator_class.new
       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
+      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)        
+      end
+    end
+    
+    def search(search_hash)
+      result = nil
+      search_hash.each do |k,v|
+        new_result = simple_search(k,v)
+        #AND's searches
+        result = intersection_of_two_arrays(new_result, result)
+      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}
+    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
+    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
         
-        accessor_method = "#{alias_type}_aliases"
-        if ! respond_to?(accessor_method)
-          self.class.send :attr_accessor, accessor_method
+    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
-        self.send("#{accessor_method}=", {}) if self.send(accessor_method).nil?
-        self.send(accessor_method).merge! obj.alias_map
       end
+      searchable_array
     end
   end
 end

data/lib/alias/method_creator_helper.rb

@@ -43,6 +43,14 @@ module Alias
       end
     end
     
+    def to_searchable_array
+      @alias_map.map {|klass,method_hash|
+        method_hash.map {|k,v| 
+          {:class=>klass, :name=>k, :alias=>v}
+        }
+      }.flatten
+    end
+    
     def create_method_aliases_per_class(klass, alias_hash)
       eval_string = ""
       alias_hash.each {|original_method, alias_methods|

data/lib/alias.rb

@@ -1,6 +1,6 @@
 $:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__))
 require 'yaml'
-require 'ostruct'
+require 'config_struct'
 require 'alias/manager'
 require 'alias/creator'
 require 'alias/constant_creator'
@@ -8,6 +8,7 @@ require 'alias/method_creator_helper'
 require 'alias/instance_method_creator'
 require 'alias/class_method_creator'
 require 'alias/core_extensions'
+require 'alias/console'
 
 module Alias
   extend self
@@ -23,18 +24,13 @@ module Alias
     file ? YAML::load(File.read(file)) : {}
   end
   
-  def init(options={})
+  def init(options={}, &block)
     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
-    
+    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)
@@ -52,4 +48,4 @@ module Alias
   def manager
     @manager ||= Manager.new
   end
-end
+end

data/lib/config_struct.rb

@@ -0,0 +1,17 @@
+require 'ostruct'
+
+class ConfigStruct < OpenStruct
+  def self.block_to_hash(block=nil)
+    config = self.new
+    if block
+      block.call(config)
+      config.to_hash
+    else
+      {}
+    end
+  end
+
+  def to_hash
+    @table
+  end
+end

data/test/alias_test.rb

@@ -39,9 +39,9 @@ class AliasTest < Test::Unit::TestCase
     
     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)
+      Alias.manager.alias_map(:instance_method)
+      Alias.manager.alias_map(:class_method)
+      Alias.manager.alias_map(:constant)
     end
     
     test "with verbose option sets config and manager verbosity" do

data/test/constant_creator_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class Alias::ConstantCreatorTest < 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
+    
+    test "to_searchable_array is an array of hashes" do
+      @creator.alias_map = {'Alias'=>'A'}
+      @creator.to_searchable_array.should == [{:name=>'Alias', :alias=>'A'}]
+    end
+  end
+end

data/test/creator_test.rb

@@ -1,35 +1,70 @@
 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 "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 "deletes existing aliases" do
-      h1 = {"Alias::ConstantCreator"=>"Alias::Creator", "Array"=>"Ar"}
-      @creator.delete_existing_aliases(h1)
-      h1.should == {"Array"=>"Ar"}
+    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 "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 "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
     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

@@ -4,49 +4,107 @@ 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 "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 "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 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.instance_method_aliases.should == {'SampleClass'=>{:whoop=>:can_of_wass}}
-      SampleClass.new.whoop.should == SampleClass.new.can_of_wass
-    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.class_method_aliases
-      SampleClass.capohow.should == SampleClass.cap
-    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
+      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
+      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
+      end
     end
-  
+    
 end

data/test/method_creator_helper_test.rb

@@ -25,6 +25,11 @@ class Alias::MethodCreatorHelperTest < Test::Unit::TestCase
       @creator.create(h2)
       assert_equal 'blah', String.n('blah')
     end
+    
+    test "to_searchable_array is an array of hashes" do
+      @creator.alias_map = {'String'=>{'name'=>'n'}}
+      @creator.to_searchable_array.should == [{:name=>'name', :alias=>'n', :class=>'String'}]
+    end
   end
   
   context "InstanceMethodCreator" do

data/test/test_helper.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cldwalker-alias
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-20 00:00:00 -08:00
+date: 2009-02-23 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -19,15 +19,18 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
 files: 
 - Rakefile
+- VERSION.yml
 - README.rdoc
 - LICENSE.txt
 - aliases.yml.example
 - lib/alias
 - lib/alias/class_method_creator.rb
+- lib/alias/console.rb
 - lib/alias/constant_creator.rb
 - lib/alias/core_extensions.rb
 - lib/alias/creator.rb
@@ -35,8 +38,10 @@ files:
 - lib/alias/manager.rb
 - lib/alias/method_creator_helper.rb
 - lib/alias.rb
+- lib/config_struct.rb
 - test/alias_test.rb
 - test/aliases.yml
+- test/constant_creator_test.rb
 - test/core_extensions_test.rb
 - test/creator_test.rb
 - test/manager_test.rb