module Sinatra::RespondWith

def self.engines
  engines = {
    css: %i[sass scss],
    xml: %i[builder nokogiri],
    html: %i[erb erubi haml hamlit slim liquid
             mab markdown rdoc],
    all: (Sinatra::Templates.instance_methods.map(&:to_sym) +
      [:mab] - %i[find_template markaby]),
    json: [:yajl]
  }
  engines.default = []
  defined?(JRUBY_VERSION) ? jrubyify(engines) : engines
end

def self.jrubyify(engs)
  not_supported = [:markdown]
  engs.each_key do |key|
    engs[key].collect! { |eng| eng == :yajl ? :json_pure : eng }
    engs[key].delete_if { |eng| not_supported.include?(eng) }
  end
  engs
end

def self.registered(base)
  base.set :ext_map, Hash.new { |h, k| h[k] = [] }
  base.set :template_engines, engines
  base.remap_extensions
  base.helpers Helpers
end

def compile!(verb, path, block, **options)
  options[:provides] ||= respond_to if respond_to
  super
end

def mime_type(*)
  result = super
  remap_extensions
  result
end

def remap_extensions
  ext_map.clear
  Rack::Mime::MIME_TYPES.each { |e, t| ext_map[t] << e[1..].to_sym }
  ext_map['text/javascript'] << 'js'
  ext_map['text/xml'] << 'xml'
end

def rendering_method(engine)
  return [engine] if Sinatra::Templates.method_defined? engine
  return [:mab] if engine.to_sym == :markaby
  %i[render engine]
end

def respond_to(*formats)
  @respond_to ||= nil
  if formats.any?
    @respond_to ||= []
    @respond_to.concat formats
  elsif @respond_to.nil? && superclass.respond_to?(:respond_to)
    superclass.respond_to
  else
    @respond_to
  end
end