alias 0.2.0

data/lib/alias/creators/class_to_instance_method_creator.rb

@@ -0,0 +1,25 @@
+# Creates instance methods which call class methods. These are delegations rather than aliases.
+# Expects a hash of classes/modules of the instance method mapped
+# to a hash of the class methods and the instance method names. 
+# For example, the hash {"MyDate"=>{'Date.today'=>'t'}} would create a MyDate.t instance method
+# which directly calls Date.today.
+class Alias::Creators::ClassToInstanceMethodCreator < Alias::Creator
+  map do |config|
+    config.inject([]) {|t,(klass,hash)|
+      t += hash.map {|k,v|
+        {:class=>klass, :to_class=>k.split('.')[0], :name=>k.split('.')[1], :alias=>v}
+      }
+    }
+  end
+
+  valid :class, :if=>:class
+  valid :to_class, :if=>:class
+  valid :alias, :unless=>:instance_method, :with=>[:class, :alias], :optional=>true
+  valid :to_method, :if=>:class_method, :with=>[:to_class, :name]
+
+  generate do |aliases|
+    aliases.map {|e|
+      %[#{class_or_module(e[:class])} ::#{e[:class]}; def #{e[:alias]}(*args, &block); #{e[:to_class]}.__send__(:#{e[:name]}, *args, &block); end; end]
+    }.join("\n")
+  end
+end

data/lib/alias/creators/constant_creator.rb

@@ -0,0 +1,11 @@
+# Creates constants of aliases expecting a hash of existing constants mapped to their aliases.
+class Alias::Creators::ConstantCreator < Alias::Creator
+  map {|config| config.map {|k,v| {:name=>k, :alias=>v}} }
+
+  valid :alias, :unless=>:constant, :optional=>true
+  valid :name, :if=>:constant
+
+  generate do |aliases|
+    aliases.map {|e| "::#{e[:alias]} = ::#{e[:name]}"}.join("\n")
+  end
+end

data/lib/alias/creators/instance_method_creator.rb

@@ -0,0 +1,19 @@
+# Creates aliases of instance methods. Expects a hash of classes/modules mapped to a hash of instance methods and their aliases
+# i.e. {"String"=>{'to_s'=>'s'}}.
+class Alias::Creators::InstanceMethodCreator < Alias::Creator
+  map do |config|
+    config.inject([]) {|t,(klass,aliases)|
+      t += aliases.map {|k,v| {:class=>klass, :name=>k, :alias=>v} }
+    }
+  end
+
+  valid :class, :if=>:class
+  valid :instance_method, :if=>:instance_method, :with=>[:class, :name]
+  valid :alias, :unless=>:instance_method, :with=>[:class, :alias], :optional=>true
+
+  generate do |aliases|
+    aliases.map {|e|
+      "#{class_or_module(e[:class])} ::#{e[:class]}; alias_method :#{e[:alias]}, :#{e[:name]}; end"
+    }.join("\n")
+  end
+end

data/lib/alias/manager.rb

@@ -0,0 +1,140 @@
+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:
+      @creators = {}
+      @verbose = false
+      @force = false
+    end
+
+    # 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
+
+    # 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
+        false
+      end
+    end
+
+    # 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
+        result = intersection_of_two_arrays(new_result, result)
+      end
+      #duplicate results in case they are modified
+      result = result.map {|e| e.dup} if result
+      result
+    end
+
+    # 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)
+      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 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/test/alias_test.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class AliasTest < Test::Unit::TestCase
+  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 "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 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 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

data/test/aliases.yml

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