class Module

def alias_attribute(new_name, old_name)
  module_eval <<-STR, __FILE__, __LINE__ + 1
    def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
    def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
    def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
  STR
end

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
  yield(aliased_target, punctuation) if block_given?
  with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
  alias_method without_method, target
  alias_method target, with_method
  case
    when public_method_defined?(without_method)
      public target
    when protected_method_defined?(without_method)
      protected target
    when private_method_defined?(without_method)
      private target
  end
end

def anonymous?
  # Uses blank? because the name of an anonymous class is an empty
  # string in 1.8, and nil in 1.9.
  name.blank? 
end

def attr_accessor_with_default(sym, default = nil, &block)
  raise 'Default value or block required' unless !default.nil? || block
  define_method(sym, block_given? ? block : Proc.new { default })
  module_eval(<<-EVAL, __FILE__, __LINE__ + 1)
    def #{sym}=(value)                        # def age=(value)
      class << self; attr_reader :#{sym} end  #   class << self; attr_reader :age end
      @#{sym} = value                         #   @age = value
    end                                       # end
  EVAL
end

def attr_internal_accessor(*attrs)
  attr_internal_reader(*attrs)
  attr_internal_writer(*attrs)
end

def attr_internal_ivar_name(attr)
  Module.attr_internal_naming_format % attr
end

def attr_internal_reader(*attrs)
  attrs.each do |attr|
    module_eval "def #{attr}() #{attr_internal_ivar_name(attr)} end", __FILE__, __LINE__
  end
end

def attr_internal_writer(*attrs)
  attrs.each do |attr|
    module_eval "def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end", __FILE__, __LINE__
  end
end

def delegate(*methods)
  options = methods.pop
  unless options.is_a?(Hash) && to = options[:to]
    raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
  end
  if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
    raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
  end
  prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
  file, line = caller.first.split(':', 2)
  line = line.to_i
  methods.each do |method|
    on_nil =
      if options[:allow_nil]
        'return'
      else
        %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
      end
    module_eval(<<-EOS, file, line - 5)
      if instance_methods(false).map(&:to_s).include?("#{prefix}#{method}")
        remove_possible_method("#{prefix}#{method}")
      end
      def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
        #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
      rescue NoMethodError                                # rescue NoMethodError
        if #{to}.nil?                                     #   if client.nil?
          #{on_nil}                                       #     return # depends on :allow_nil
        else                                              #   else
          raise                                           #     raise
        end                                               #   end
      end                                                 # end
    EOS
  end
end

def deprecate(*method_names)
  ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
end

def duplicable?
  false
end

def instance_method_names(*args)
  instance_methods(*args).map(&:to_s)
end

def local_constant_names
  local_constants.map { |c| c.to_s }
end

def local_constants
  inherited = {}
  ancestors.each do |anc|
    next if anc == self
    anc.constants.each { |const| inherited[const] = anc.const_get(const) }
  end
  constants.select do |const|
    !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
  end
end

def local_constants #:nodoc:
  constants(false)
end

def mattr_accessor(*syms)
  mattr_reader(*syms)
  mattr_writer(*syms)
end

def mattr_reader(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      @@#{sym} = nil unless defined? @@#{sym}
      def self.#{sym}
        @@#{sym}
      end
    EOS
    
    unless options[:instance_reader] == false
      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        def #{sym}
          @@#{sym}
        end
      EOS
    end
  end
end

def mattr_writer(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      def self.#{sym}=(obj)
        @@#{sym} = obj
      end
    EOS
    unless options[:instance_writer] == false
      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        def #{sym}=(obj)
          @@#{sym} = obj
        end
      EOS
    end
  end
end

def method_names(*args)
  methods(*args).map(&:to_s)
end

def parent
  parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
end

def parent_name
  unless defined? @parent_name
    @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
  end
  @parent_name
end

def parents
  parents = []
  if parent_name
    parts = parent_name.split('::')
    until parts.empty?
      parents << ActiveSupport::Inflector.constantize(parts * '::')
      parts.pop
    end
  end
  parents << Object unless parents.include? Object
  parents
end

def reachable? #:nodoc:
  !anonymous? && name.constantize.equal?(self)
rescue NameError
  false
end

def redefine_method(method, &block)
  remove_possible_method(method)
  define_method(method, &block)
end

def remove_possible_method(method)
  remove_method(method)
rescue NameError
end

def synchronize(*methods)
  options = methods.extract_options!
  unless options.is_a?(Hash) && with = options[:with]
    raise ArgumentError, "Synchronization needs a mutex. Supply an options hash with a :with key as the last argument (e.g. synchronize :hello, :with => :@mutex)."
  end
  methods.each do |method|
    aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
    if method_defined?("#{aliased_method}_without_synchronization#{punctuation}")
      raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
    end
    module_eval(<<-EOS, __FILE__, __LINE__ + 1)
      def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
        #{with}.synchronize do                                                    #   @@lock.synchronize do
          #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)
        end                                                                       #   end
      end                                                                         # end
    EOS
    alias_method_chain method, :synchronization
  end
end