# TITLE:
#
#   Module Alias Extensions
#
# FILE:
#
#   module/alias.rb
#
# DESCRIPTION:
#
#   Module alias extensions.
#
# AUTHORS:
#
#   CREDIT Thomas Saywer

class Module

  private

  # Like module_funtion but makes the instance method
  # public rather than private. This can not work
  # as a sectional modifier however.

  def module_method *meth
    module_function *meth
    public *meth
  end

  # As with alias_method, but alias both reader and writer.
  #
  #   attr_accessor :x
  #   self.x = 1
  #   alias_accessor :y, :x
  #   y #=> 1
  #   self.y = 2
  #   x #=> 2

  def alias_accessor( name, target )
    alias_method( name, target )
    alias_method( "#{name}=", "#{target}=" )
  end

  # Alias a module function so that the alias is also
  # a module function. The typical #alias_method 
  # does not do this.
  #
  #   module Demo
  #     module_function
  #     def hello
  #       "Hello"
  #     end
  #   end
  #
  #   Demo.hello    #=> Hello
  #
  #   module Demo
  #     alias_module_function( :hi , :hello )
  #   end
  #
  #   Demo.hi       #=> Hello
  #
  def alias_module_function( new, old )
    alias_method( new, old )
    module_function( new )
  end

  # Encapsulates the common pattern of:
  #
  #   alias_method :foo_without_feature, :foo
  #   alias_method :foo, :foo_with_feature
  #
  # With this, you simply do:
  #
  #   alias_method_chain :foo, :feature
  #
  # And both aliases are set up for you.
  #
  # Query and bang methods (foo?, foo!) keep the same punctuation:
  #
  #   alias_method_chain :foo?, :feature
  #
  # is equivalent to
  #
  #   alias_method :foo_without_feature?, :foo?
  #   alias_method :foo?, :foo_without_feature?
  #
  # so you can safely chain foo, foo?, and foo! with the same feature.
  #--
  # Credit goes to bitsweat and Rails.
  #++
  def alias_method_chain(target, feature)
    # Strip out punctuation on predicates or bang methods since
    # e.g. target?_without_feature is not a valid method name.
    aliased_target, punctuation = target.to_s.sub(/([?!])$/, ''), $1
    alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
    alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
  end

end


#  _____         _
# |_   _|__  ___| |_
#   | |/ _ \/ __| __|
#   | |  __/\__ \ |_
#   |_|\___||___/\__|
#
=begin test

  require 'test/unit'

  class TCModule < Test::Unit::TestCase

    module MockModule
      # for alias_module_method
      def x ; 33 ; end
      module_function :x
      alias_module_function :y, :x
    end

    def test_alias_module_function
      assert_equal( 33, MockModule.y )
      #assert_equal( 33, @m.send(:y) ) # use send b/c private
    end

    module X
      def self.included(base)
        base.module_eval {
          alias_method_chain :foo, :feature
        }
      end
      def foo_with_feature
        foo_without_feature + '!'
      end
    end

    class Y
      def foo
        "FOO"
      end
      include X
      #alias_method_chain :foo, :feature
    end

    def test_001
      y = Y.new
      assert_equal( "FOO!", y.foo )
    end

  end

=end