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)
  ActiveSupport::Deprecation.warn("alias_method_chain is deprecated. Please, use Module#prepend instead. From module, you can access the original method using super.")
  # Strip out punctuation on predicates, bang or writer 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@/, '')
  # use native attr_* methods as they are faster on some Ruby implementations
  send("attr_#{type}", internal_name)
  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, to: nil, prefix: nil, allow_nil: nil)
  unless 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 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
  location = caller_locations(1, 1).first
  file, line = location.path, location.lineno
  to = to.to_s
  to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
  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 method calls 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 conceptually, from the user point of view, the delegator should
    # be doing one call.
    if allow_nil
      method_def = [
        "def #{method_prefix}#{method}(#{definition})",
        "_ = #{to}",
        "if !_.nil? || nil.respond_to?(:#{method})",
        "  _.#{method}(#{definition})",
        "end",
      "end"
      ].join ';'
    else
      exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
      method_def = [
        "def #{method_prefix}#{method}(#{definition})",
        " _ = #{to}",
        "  _.#{method}(#{definition})",
        "rescue NoMethodError => e",
        "  if _.nil? && e.name == :#{method}",
        "    #{exception}",
        "  else",
        "    raise",
        "  end",
        "end"
      ].join ';'
    end
    module_eval(method_def, file, line)
  end
end

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

def local_constants #:nodoc:
  ActiveSupport::Deprecation.warn(<<-MSG.squish)
    Module#local_constants is deprecated and will be removed in Rails 5.1.
    Use Module#constants(false) instead.
  MSG
  constants(false)
end

def mattr_accessor(*syms, &blk)
  mattr_reader(*syms, &blk)
  mattr_writer(*syms)
end

def mattr_reader(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /\A[_A-Za-z]\w*\z/
    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
    class_variable_set("@@#{sym}", yield) if block_given?
  end
end

def mattr_writer(*syms)
  options = syms.extract_options!
  syms.each do |sym|
    raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /\A[_A-Za-z]\w*\z/
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      @@#{sym} = nil unless defined? @@#{sym}
      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
    send("#{sym}=", yield) if block_given?
  end
end

def method_visibility(method) # :nodoc:
  case
  when private_method_defined?(method)
    :private
  when protected_method_defined?(method)
    :protected
  else
    :public
  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
    @parent_name = parent_name unless frozen?
    parent_name
  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)
  ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
    Module#qualified_const_defined? is deprecated in favour of the builtin
    Module#const_defined? and will be removed in Rails 5.1.
  MESSAGE
  ActiveSupport::QualifiedConstUtils.raise_if_absolute(path)
  ActiveSupport::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)
  ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
    Module#qualified_const_get is deprecated in favour of the builtin
    Module#const_get and will be removed in Rails 5.1.
  MESSAGE
  ActiveSupport::QualifiedConstUtils.raise_if_absolute(path)
  ActiveSupport::QualifiedConstUtils.names(path).inject(self) do |mod, name|
    mod.const_get(name)
  end
end

def qualified_const_set(path, value)
  ActiveSupport::Deprecation.warn(<<-MESSAGE.squish)
    Module#qualified_const_set is deprecated in favour of the builtin
    Module#const_set and will be removed in Rails 5.1.
  MESSAGE
  ActiveSupport::QualifiedConstUtils.raise_if_absolute(path)
  const_name = path.demodulize
  mod_name = path.deconstantize
  mod = mod_name.empty? ? self : 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)
  visibility = method_visibility(method)
  remove_possible_method(method)
  define_method(method, &block)
  send(visibility, method)
end

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

def remove_possible_singleton_method(method)
  singleton_class.instance_eval do
    remove_possible_method(method)
  end
end

def thread_mattr_accessor(*syms, &blk)
  thread_mattr_reader(*syms, &blk)
  thread_mattr_writer(*syms, &blk)
end

def thread_mattr_reader(*syms) # :nodoc:
  options = syms.extract_options!
  syms.each do |sym|
    raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      def self.#{sym}
        Thread.current["attr_"+ name + "_#{sym}"]
      end
    EOS
    unless options[:instance_reader] == false || options[:instance_accessor] == false
      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        def #{sym}
          Thread.current["attr_"+ self.class.name + "_#{sym}"]
        end
      EOS
    end
  end
end

def thread_mattr_writer(*syms) # :nodoc:
  options = syms.extract_options!
  syms.each do |sym|
    raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /^[_A-Za-z]\w*$/
    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
      def self.#{sym}=(obj)
        Thread.current["attr_"+ name + "_#{sym}"] = obj
      end
    EOS
    unless options[:instance_writer] == false || options[:instance_accessor] == false
      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        def #{sym}=(obj)
          Thread.current["attr_"+ self.class.name + "_#{sym}"] = obj
        end
      EOS
    end
  end
end