class Middleman::Rack

def call(env)

Parameters:
  • env () -- Rack environment 
def call(env)
  # Store environment, request and response for later
  req = ::Rack::Request.new(env)
  res = ::Rack::Response.new
  logger.debug "== Request: #{env['PATH_INFO']}"
  # Catch :halt exceptions and use that response if given
  catch(:halt) do
    process_request(env, req, res)
    res.status = 404
    res.finish
  end
end

def halt(response)

Parameters:
  • response (String) -- Response value 
def halt(response)
  throw :halt, response
end

def initialize(middleman) 

def initialize(middleman)
  @middleman = middleman
end

def not_found(res, path)

Halt request and return 404 
def not_found(res, path)
  res.status = 404
  res.write "<html><head></head><body><h1>File Not Found</h1><p>#{path}</p></body></html>"
  res.finish
end

def process_request(env, req, res)

Parameters:
  • res (Rack::Response) --
  • req (Rack::Request) --
  • env () -- 
def process_request(env, req, res)
  start_time = Time.now
  request_path = URI.decode(env['PATH_INFO'].dup)
  if request_path.respond_to? :force_encoding
    request_path.force_encoding('UTF-8')
  end
  request_path = ::Middleman::Util.full_path(request_path, @middleman)
  full_request_path = File.join(env['SCRIPT_NAME'], request_path) # Path including rack mount
  # Run before callbacks
  @middleman.execute_callbacks(:before)
  # Get the resource object for this path
  resource = @middleman.sitemap.find_resource_by_destination_path(request_path.gsub(' ', '%20'))
  # Return 404 if not in sitemap
  return not_found(res, full_request_path) unless resource && !resource.ignored?
  # If this path is a binary file, send it immediately
  return send_file(resource, env) if resource.binary?
  res['Content-Type'] = resource.content_type || 'text/plain'
  begin
    # Write out the contents of the page
    res.write resource.render({}, rack: { request: req })
    # Valid content is a 200 status
    res.status = 200
  rescue Middleman::TemplateRenderer::TemplateNotFound => e
    res.write "Error: #{e.message}"
    res.status = 500
  end
  # End the request
  logger.debug "== Finishing Request: #{resource.destination_path} (#{(Time.now - start_time).round(2)}s)"
  halt res.finish
end

def send_file(resource, env)

Immediately send static file 
def send_file(resource, env)
  file      = ::Rack::File.new nil
  file.path = resource.file_descriptor[:full_path]
  response = file.serving(env)
  status = response[0]
  response[1]['Content-Encoding'] = 'gzip' if %w(.svgz .gz).include?(resource.ext)
  # Do not set Content-Type if status is 1xx, 204, 205 or 304, otherwise
  # Rack will throw an error (500)
  if !(100..199).include?(status) && ![204, 205, 304].include?(status)
    response[1]['Content-Type'] = resource.content_type || 'application/octet-stream'
  end
  halt response
end

def to_app 

def to_app
  app = ::Rack::Builder.new
  app.use ::Rack::Lint
  app.use ::Rack::Head
  @middleman.middleware.each do |middleware|
    app.use(middleware[:class], *middleware[:options], &middleware[:block])
  end
  inner_app = self
  app.map('/') { run inner_app }
  @middleman.mappings.each do |mapping|
    app.map(mapping[:path], &mapping[:block])
  end
  app
end