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 = "#{aliased_target}_with_#{feature}#{punctuation}"
  without_method = "#{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?
  name.nil?
end

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

def attr_internal_define(attr_name, type)
  internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, '')
  class_eval do # class_eval is necessary on 1.9 or else the methods a made private
    # use native attr_* methods as they are faster on some Ruby implementations
    send("attr_#{type}", internal_name)
  end
  attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
  alias_method attr_name, internal_name
  remove_method internal_name
end

def attr_internal_ivar_name(attr)
  Module.attr_internal_naming_format % attr
end

def attr_internal_reader(*attrs)
  attrs.each {|attr_name| attr_internal_define(attr_name, :reader)}
end

def attr_internal_writer(*attrs)
  attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}
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
  prefix, allow_nil = options.values_at(:prefix, :allow_nil)
  if prefix == true && to =~ /^[^a-z_]/
    raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
  end
  method_prefix = \
    if prefix
      "#{prefix == true ? to : prefix}_"
    else
      ''
    end
  file, line = caller.first.split(':', 2)
  line = line.to_i
  to = to.to_s
  to = 'self.class' if to == 'class'
  methods.each do |method|
    # Attribute writer methods only accept one argument. Makes sure []=
    # methods still accept two arguments.
    definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
    # The following generated methods call the target exactly once, storing
    # the returned value in a dummy variable.
    #
    # Reason is twofold: On one hand doing less calls is in general better.
    # On the other hand it could be that the target has side-effects,
    # whereas conceptualy, from the user point of view, the delegator should
    # be doing one call.
    if allow_nil
      module_eval(<<-EOS, file, line - 3)
        def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
          _ = #{to}                                         #   _ = client
          if !_.nil? || nil.respond_to?(:#{method})         #   if !_.nil? || nil.respond_to?(:name)
            _.#{method}(#{definition})                      #     _.name(*args, &block)
          end                                               #   end
        end                                                 # end
      EOS
    else
      exception = %(raise "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
      module_eval(<<-EOS, file, line - 2)
        def #{method_prefix}#{method}(#{definition})                                          # def customer_name(*args, &block)
          _ = #{to}                                                                           #   _ = client
          _.#{method}(#{definition})                                                          #   _.name(*args, &block)
        rescue NoMethodError => e                                                             # rescue NoMethodError => e
          location = "%s:%d:in `%s'" % [__FILE__, __LINE__ - 2, '#{method_prefix}#{method}']  #   location = "%s:%d:in `%s'" % [__FILE__, __LINE__ - 2, 'customer_name']
          if _.nil? && e.backtrace.first == location                                          #   if _.nil? && e.backtrace.first == location
            #{exception}                                                                      #     # add helpful message to the exception
          else                                                                                #   else
            raise                                                                             #     raise
          end                                                                                 #   end
        end                                                                                   # end
      EOS
    end
  end
end

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

def local_constant_names
  ActiveSupport::Deprecation.warn 'Module#local_constant_names is deprecated, use Module#local_constants instead'
  local_constants.map { |c| c.to_s }
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|
    raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      @@#{sym} = nil unless defined? @@#{sym}
      def self.#{sym}
        @@#{sym}
      end
    EOS
    unless options[:instance_reader] == false || options[:instance_accessor] == 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|
    raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      def self.#{sym}=(obj)
        @@#{sym} = obj
      end
    EOS
    unless options[:instance_writer] == false || options[:instance_accessor] == false
      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        def #{sym}=(obj)
          @@#{sym} = obj
        end
      EOS
    end
  end
end

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

def parent_name
  if defined? @parent_name
    @parent_name
  else
    @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
  end
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 qualified_const_defined?(path, search_parents=true)
  QualifiedConstUtils.raise_if_absolute(path)
  QualifiedConstUtils.names(path).inject(self) do |mod, name|
    return unless mod.const_defined?(name, search_parents)
    mod.const_get(name)
  end
  return true
end

def qualified_const_get(path)
  QualifiedConstUtils.raise_if_absolute(path)
  QualifiedConstUtils.names(path).inject(self) do |mod, name|
    mod.const_get(name)
  end
end

def qualified_const_set(path, value)
  QualifiedConstUtils.raise_if_absolute(path)
  const_name = path.demodulize
  mod_name = path.deconstantize
  mod = mod_name.empty? ? self : qualified_const_get(mod_name)
  mod.const_set(const_name, value)
end

def reachable? #:nodoc:
  !anonymous? && name.safe_constantize.equal?(self)
end

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

def remove_possible_method(method)
  if method_defined?(method) || private_method_defined?(method)
    undef_method(method)
  end
end