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(env)

Inspect configuration 
def config(env)
  global_config = @middleman.inst.config.all_settings.map {|c| ConfigSetting.new(c) }
  extension_config = Hash[@middleman.inst.extensions.map do |ext_name, extension|
                            opts = if extension.is_a?(::Middleman::Extension)
                                     extension.options.all_settings.map {|c| ConfigSetting.new(c) }
                                   else 
                                     nil
                                   end
                            [ext_name, opts]
                          end]
  template('config.html.erb', 
           :global_config => global_config,
           :extension_config => extension_config, 
           :registered_extensions => Middleman::Extensions.registered.dup)
end

def index(env)

The index page 
def index(env)
  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(env)

Inspect the sitemap 
def sitemap(env)
  resources = @middleman.inst.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(nil, locals)
  response(content)
end