class Middleman::MetaPages::Application

on Sinatra or figure out how to host Middleman inside Middleman.
Built using a ghetto little Rack web framework cobbled together because I didn’t want to depend
application and its configuration. Analogous to Firefox/Chrome’s “about:” pages.
Metadata pages to be served in preview, in order to present information about the Middleman

def call(*args) 

def call(*args)
  @rack_app.call(*args)
end

def config(_)

Inspect configuration 
def config(_)
  global_config = @middleman.config.all_settings.map { |c| ConfigSetting.new(c) }
  extension_config = {}
  auto_activated_config = {}
  @middleman.extensions.each do |ext_name, extension|
    if ::Middleman::Extensions.auto_activated.include? ext_name
      auto_activated_config[ext_name] = extension_options(extension)
      next
    end
    if extension.is_a?(Hash)
      # Multiple instance extension
      if extension.size == 1
        extension_config[ext_name] = extension_options(extension.values.first)
      else
        extension.each do |inst, ext|
          extension_config["#{ext_name} (#{inst})"] = extension_options(ext)
        end
      end
    else
      extension_config[ext_name] = extension_options(extension)
    end
  end
  template('config.html.erb',
           global_config: global_config,
           extension_config: extension_config,
           auto_activated_config: auto_activated_config,
           registered_extensions: Middleman::Extensions.registered.dup)
end

def extension_options(extension) 

def extension_options(extension)
  extension.options.all_settings.map { |c| ConfigSetting.new(c) }
end

def index(_)

The index page 
def index(_)
  template('index.html.erb')
end

def initialize(middleman) 

def initialize(middleman)
  # Hold a reference to the middleman application
  @middleman = middleman
  meta_pages = self
  @rack_app = ::Rack::Builder.new do
    # Serve assets from metadata/assets
    use ::Rack::Static, urls: ['/assets'], root: File.join(File.dirname(__FILE__), 'meta_pages')
    map '/' do
      run meta_pages.method(:index)
    end
    map '/sitemap' do
      run meta_pages.method(:sitemap)
    end
    map '/config' do
      run meta_pages.method(:config)
    end
  end
end

def response(content)

Respond to an HTML request 
def response(content)
  [200, { 'Content-Type' => 'text/html' }, Array(content)]
end

def sitemap(_)

Inspect the sitemap 
def sitemap(_)
  resources = @middleman.sitemap.resources(true)
  sitemap_tree = SitemapTree.new
  resources.each do |resource|
    sitemap_tree.add_resource resource
  end
  template('sitemap.html.erb', sitemap_tree: sitemap_tree)
end

def template(template_name, locals={})

Render a template with the given name and locals 
def template(template_name, locals={})
  template_path = File.join(File.dirname(__FILE__), 'meta_pages', 'templates', template_name)
  content = Tilt.new(template_path).render(::Object.new, locals)
  response(content)
end