class Sinatra::Helpers::Stream::Base

# File lib/sinatra/base.rb, line 909
def initialize(app = nil)
  super()
  @app = app
  @template_cache = Tilt::Cache.new
  yield self if block_given?
end

# File lib/sinatra/base.rb, line 944
def self.settings
  self
end

# File lib/sinatra/base.rb, line 1364
def add_filter(type, path = /.*/, **options, &block)
  filters[type] << compile!(type, path, block, options)
end

# File lib/sinatra/base.rb, line 1359
def after(path = /.*/, **options, &block)
  add_filter(:after, path, options, &block)
end

# File lib/sinatra/base.rb, line 1352
def before(path = /.*/, **options, &block)
  add_filter(:before, path, options, &block)
end

# File lib/sinatra/base.rb, line 1498
def build(app)
  builder = Rack::Builder.new
  setup_default_middleware builder
  setup_middleware builder
  builder.run app
  builder
end

# File lib/sinatra/base.rb, line 1506
def call(env)
  synchronize { prototype.call(env) }
end

# File lib/sinatra/base.rb, line 1512
def caller_files
  cleaned_caller(1).flatten
end

# File lib/sinatra/base.rb, line 1518
def caller_locations
  cleaned_caller 2
end

# File lib/sinatra/base.rb, line 1744
def cleaned_caller(keep = 3)
  caller(1).
    map!    { |line| line.split(/:(?=\d|in )/, 3)[0,keep] }.
    reject { |file, *_| CALLERS_TO_IGNORE.any? { |pattern| file =~ pattern } }
end

# File lib/sinatra/base.rb, line 1645
def compile(path, route_mustermann_opts = {})
  Mustermann.new(path, mustermann_opts.merge(route_mustermann_opts))
end

# File lib/sinatra/base.rb, line 1626
def compile!(verb, path, block, **options)
  # Because of self.options.host
  host_name(options.delete(:host)) if options.key?(:host)
  # Pass Mustermann opts to compile()
  route_mustermann_opts = options.key?(:mustermann_opts) ? options.delete(:mustermann_opts) : {}.freeze

  options.each_pair { |option, args| send(option, *args) }

  pattern                 = compile(path, route_mustermann_opts)
  method_name             = "#{verb} #{path}"
  unbound_method          = generate_method(method_name, &block)
  conditions, @conditions = @conditions, []
  wrapper                 = block.arity != 0 ?
    proc { |a, p| unbound_method.bind(a).call(*p) } :
    proc { |a, p| unbound_method.bind(a).call }

  [ pattern, conditions, wrapper ]
end

# File lib/sinatra/base.rb, line 1370
def condition(name = "#{caller.first[/`.*'/]} condition", &block)
  @conditions << generate_method(name, &block)
end

# File lib/sinatra/base.rb, line 1430
def configure(*envs)
  yield self if envs.empty? || envs.include?(environment.to_sym)
end

# File lib/sinatra/base.rb, line 1564
def define_singleton(name, content = Proc.new)
  singleton_class.class_eval do
    undef_method(name) if method_defined? name
    String === content ? class_eval("def #{name}() #{content}; end") : define_method(name, &content)
  end
end

# File lib/sinatra/base.rb, line 1399
def delete(path, opts = {}, &bk)  route 'DELETE',  path, opts, &bk end

# File lib/sinatra/base.rb, line 1712
def detect_rack_handler
  servers = Array(server)
  servers.each do |server_name|
    begin
      return Rack::Handler.get(server_name.to_s)
    rescue LoadError, NameError
    end
  end
  fail "Server handler (#{servers.join(',')}) not found."
end

# File lib/sinatra/base.rb, line 1424
def development?; environment == :development end

# File lib/sinatra/base.rb, line 1268
def disable(*opts)
  opts.each { |key| set(key, false) }
end

# File lib/sinatra/base.rb, line 1263
def enable(*opts)
  opts.each { |key| set(key, true) }
end

# File lib/sinatra/base.rb, line 1275
def error(*codes, &block)
  args  = compile! "ERROR", /.*/, block
  codes = codes.flat_map(&method(:Array))
  codes << Exception if codes.empty?
  codes << Sinatra::NotFound if codes.include?(404)
  codes.each { |c| (@errors[c] ||= []) << args }
end

# File lib/sinatra/base.rb, line 1208
def extensions
  if superclass.respond_to?(:extensions)
    (@extensions + superclass.extensions).uniq
  else
    @extensions
  end
end

# File lib/sinatra/base.rb, line 1759
def self.force_encoding(data, encoding = default_encoding)
  return if data == settings || data.is_a?(Tempfile)
  if data.respond_to? :force_encoding
    data.force_encoding(encoding).encode!
  elsif data.respond_to? :each_value
    data.each_value { |v| force_encoding(v, encoding) }
  elsif data.respond_to? :each
    data.each { |v| force_encoding(v, encoding) }
  end
  data
end

# File lib/sinatra/base.rb, line 1619
def generate_method(method_name, &block)
  define_method(method_name, &block)
  method = instance_method method_name
  remove_method method_name
  method
end

# File lib/sinatra/base.rb, line 1389
def get(path, opts = {}, &block)
  conditions = @conditions.dup
  route('GET', path, opts, &block)

  @conditions = conditions
  route('HEAD', path, opts, &block)
end

# File lib/sinatra/base.rb, line 1400
def head(path, opts = {}, &bk)    route 'HEAD',    path, opts, &bk end

# File lib/sinatra/base.rb, line 1408
def helpers(*extensions, &block)
  class_eval(&block)   if block_given?
  include(*extensions) if extensions.any?
end

# File lib/sinatra/base.rb, line 1572
def host_name(pattern)
  condition { pattern === request.host }
end

# File lib/sinatra/base.rb, line 1723
def inherited(subclass)
  subclass.reset!
  subclass.set :app_file, caller_files.first unless subclass.app_file?
  super
end

# File lib/sinatra/base.rb, line 1301
def inline_templates=(file = nil)
  file = (file.nil? || file == true) ? (caller_files.first || File.expand_path($0)) : file

  begin
    io = ::IO.respond_to?(:binread) ? ::IO.binread(file) : ::IO.read(file)
    app, data = io.gsub("\r\n", "\n").split(/^__END__$/, 2)
  rescue Errno::ENOENT
    app, data = nil
  end

  if data
    if app and app =~ /([^\n]*\n)?#[^\n]*coding: *(\S+)/m
      encoding = $2
    else
      encoding = settings.default_encoding
    end
    lines = app.count("\n") + 1
    template = nil
    force_encoding data, encoding
    data.each_line do |line|
      lines += 1
      if line =~ /^@@\s*(.*\S)\s*$/
        template = force_encoding(String.new, encoding)
        templates[$1.to_sym] = [template, file, lines]
      elsif template
        template << line
      end
    end
  end
end

# File lib/sinatra/base.rb, line 1615
def invoke_hook(name, *args)
  extensions.each { |e| e.send(name, *args) if e.respond_to?(name) }
end

# File lib/sinatra/base.rb, line 1295
def layout(name = :layout, &block)
  template name, &block
end

# File lib/sinatra/base.rb, line 1403
def link(path, opts = {}, &bk)    route 'LINK',    path, opts, &bk end

# File lib/sinatra/base.rb, line 1217
def middleware
  if superclass.respond_to?(:middleware)
    superclass.middleware + @middleware
  else
    @middleware
  end
end

# File lib/sinatra/base.rb, line 1333
def mime_type(type, value = nil)
  return type      if type.nil?
  return type.to_s if type.to_s.include?('/')
  type = ".#{type}" unless type.to_s[0] == ?.
  return Rack::Mime.mime_type(type, nil) unless value
  Rack::Mime::MIME_TYPES[type] = value
end

# File lib/sinatra/base.rb, line 1344
def mime_types(type)
  type = mime_type type
  type =~ /^application\/(xml|javascript)$/ ? [type, "text/#$1"] : [type]
end

# File lib/sinatra/base.rb, line 1491
def new(*args, &bk)
  instance = new!(*args, &bk)
  Wrapper.new(build(instance).to_app, instance)
end

# File lib/sinatra/base.rb, line 1284
def not_found(&block)
  error(404, &block)
end

# File lib/sinatra/base.rb, line 1401
def options(path, opts = {}, &bk) route 'OPTIONS', path, opts, &bk end

# File lib/sinatra/base.rb, line 1402
def patch(path, opts = {}, &bk)   route 'PATCH',   path, opts, &bk end

# File lib/sinatra/base.rb, line 1398
def post(path, opts = {}, &bk)    route 'POST',    path, opts, &bk end

# File lib/sinatra/base.rb, line 1425
def production?;  environment == :production  end

# File lib/sinatra/base.rb, line 1481
def prototype
  @prototype ||= new
end

# File lib/sinatra/base.rb, line 1591
def provides(*types)
  types.map! { |t| mime_types(t) }
  types.flatten!
  condition do
    if type = response['Content-Type']
      types.include? type or types.include? type[/^[^;]+/]
    elsif type = request.preferred_type(types)
      params = (type.respond_to?(:params) ? type.params : {})
      content_type(type, params)
      true
    else
      false
    end
  end
end

# File lib/sinatra/base.rb, line 1374
def public=(value)
  warn ":public is no longer used to avoid overloading Module#public, use :public_folder or :public_dir instead"
  set(:public_folder, value)
end

# File lib/sinatra/base.rb, line 1383
def public_dir
  public_folder
end

# File lib/sinatra/base.rb, line 1379
def public_dir=(value)
  self.public_folder = value
end

# File lib/sinatra/base.rb, line 1397
def put(path, opts = {}, &bk)     route 'PUT',     path, opts, &bk end

# File lib/sinatra/base.rb, line 1441
def quit!
  return unless running?
  # Use Thin's hard #stop! if available, otherwise just #stop.
  running_server.respond_to?(:stop!) ? running_server.stop! : running_server.stop
  $stderr.puts "== Sinatra has ended his set (crowd applauds)" unless suppress_messages?
  set :running_server, nil
  set :handler_name, nil
end

# File lib/sinatra/base.rb, line 1415
def register(*extensions, &block)
  extensions << Module.new(&block) if block_given?
  @extensions += extensions
  extensions.each do |extension|
    extend extension
    extension.registered(self) if extension.respond_to?(:registered)
  end
end

# File lib/sinatra/base.rb, line 1191
def reset!
  @conditions     = []
  @routes         = {}
  @filters        = {:before => [], :after => []}
  @errors         = {}
  @middleware     = []
  @prototype      = nil
  @extensions     = []

  if superclass.respond_to?(:templates)
    @templates = Hash.new { |hash, key| superclass.templates[key] }
  else
    @templates = {}
  end
end

# File lib/sinatra/base.rb, line 1607
def route(verb, path, options = {}, &block)
  enable :empty_path_info if path == "" and empty_path_info.nil?
  signature = compile!(verb, path, block, options)
  (@routes[verb] ||= []) << signature
  invoke_hook(:route_added, verb, path, block)
  signature
end

# File lib/sinatra/base.rb, line 1455
def run!(options = {}, &block)
  return if running?
  set options
  handler         = detect_rack_handler
  handler_name    = handler.name.gsub(/.*::/, '')
  server_settings = settings.respond_to?(:server_settings) ? settings.server_settings : {}
  server_settings.merge!(:Port => port, :Host => bind)

  begin
    start_server(handler, server_settings, handler_name, &block)
  rescue Errno::EADDRINUSE
    $stderr.puts "== Someone is already performing on port #{port}!"
    raise
  ensure
    quit!
  end
end

# File lib/sinatra/base.rb, line 1476
def running?
  running_server?
end

# File lib/sinatra/base.rb, line 1227
def set(option, value = (not_set = true), ignore_setter = false, &block)
  raise ArgumentError if block and !not_set
  value, not_set = block, false if block

  if not_set
    raise ArgumentError unless option.respond_to?(:each)
    option.each { |k,v| set(k, v) }
    return self
  end

  if respond_to?("#{option}=") and not ignore_setter
    return __send__("#{option}=", value)
  end

  setter = proc { |val| set option, val, true }
  getter = proc { value }

  case value
  when Proc
    getter = value
  when Symbol, Integer, FalseClass, TrueClass, NilClass
    getter = value.inspect
  when Hash
    setter = proc do |val|
      val = value.merge val if Hash === val
      set option, val, true
    end
  end

  define_singleton("#{option}=", setter)
  define_singleton(option, getter)
  define_singleton("#{option}?", "!!#{option}") unless method_defined? "#{option}?"
  self
end

# File lib/sinatra/base.rb, line 1676
def setup_common_logger(builder)
  builder.use Sinatra::CommonLogger
end

# File lib/sinatra/base.rb, line 1680
def setup_custom_logger(builder)
  if logging.respond_to? :to_int
    builder.use Rack::Logger, logging
  else
    builder.use Rack::Logger
  end
end

# File lib/sinatra/base.rb, line 1649
def setup_default_middleware(builder)
  builder.use ExtendedRack
  builder.use ShowExceptions       if show_exceptions?
  builder.use Rack::MethodOverride if method_override?
  builder.use Rack::Head
  setup_logging    builder
  setup_sessions   builder
  setup_protection builder
end

# File lib/sinatra/base.rb, line 1663
def setup_logging(builder)
  if logging?
    setup_common_logger(builder)
    setup_custom_logger(builder)
  elsif logging == false
    setup_null_logger(builder)
  end
end

# File lib/sinatra/base.rb, line 1659
def setup_middleware(builder)
  middleware.each { |c,a,b| builder.use(c, *a, &b) }
end

# File lib/sinatra/base.rb, line 1672
def setup_null_logger(builder)
  builder.use Rack::NullLogger
end

# File lib/sinatra/base.rb, line 1688
def setup_protection(builder)
  return unless protection?
  options = Hash === protection ? protection.dup : {}
  options = {
    img_src:  "'self' data:",
    font_src: "'self'"
  }.merge options

  protect_session = options.fetch(:session) { sessions? }
  options[:without_session] = !protect_session

  options[:reaction] ||= :drop_session

  builder.use Rack::Protection, options
end

# File lib/sinatra/base.rb, line 1704
def setup_sessions(builder)
  return unless sessions?
  options = {}
  options[:secret] = session_secret if session_secret?
  options.merge! sessions.to_hash if sessions.respond_to? :to_hash
  builder.use session_store, options
end

# File lib/sinatra/base.rb, line 1548
def setup_traps
  if traps?
    at_exit { quit! }

    [:INT, :TERM].each do |signal|
      old_handler = trap(signal) do
        quit!
        old_handler.call if old_handler.respond_to?(:call)
      end
    end

    set :traps, false
  end
end

# File lib/sinatra/base.rb, line 1525
def start_server(handler, server_settings, handler_name)
  # Ensure we initialize middleware before startup, to match standard Rack
  # behavior, by ensuring an instance exists:
  prototype
  # Run the instance we created:
  handler.run(self, server_settings) do |server|
    unless suppress_messages?
      $stderr.puts "== Sinatra (v#{Sinatra::VERSION}) has taken the stage on #{port} for #{environment} with backup from #{handler_name}"
    end

    setup_traps
    set :running_server, server
    set :handler_name,   handler_name
    server.threaded = settings.threaded if server.respond_to? :threaded=

    yield server if block_given?
  end
end

# File lib/sinatra/base.rb, line 1544
def suppress_messages?
  handler_name =~ /cgi/i || quiet
end

# File lib/sinatra/base.rb, line 1730
def synchronize(&block)
  if lock?
    @@mutex.synchronize(&block)
  else
    yield
  end
end

# File lib/sinatra/base.rb, line 1289
def template(name, &block)
  filename, line = caller_locations.first
  templates[name] = [block, filename, line.to_i]
end

# File lib/sinatra/base.rb, line 1426
def test?;        environment == :test        end

# File lib/sinatra/base.rb, line 1404
def unlink(path, opts = {}, &bk)  route 'UNLINK',  path, opts, &bk end

# File lib/sinatra/base.rb, line 1435
def use(middleware, *args, &block)
  @prototype = nil
  @middleware << [middleware, args, block]
end

# File lib/sinatra/base.rb, line 1578
def user_agent(pattern)
  condition do
    if request.user_agent.to_s =~ pattern
      @params[:agent] = $~[1..-1]
      true
    else
      false
    end
  end
end

# File lib/sinatra/base.rb, line 1739
def warn(message)
  super message + "\n\tfrom #{cleaned_caller.first.join(':')}"
end

# File lib/sinatra/base.rb, line 917
def call(env)
  dup.call!(env)
end

# File lib/sinatra/base.rb, line 974
def forward
  fail "downstream app not set" unless @app.respond_to? :call
  status, headers, body = @app.call env
  @response.status = status
  @response.body = body
  @response.headers.merge! headers
  nil
end

# File lib/sinatra/base.rb, line 961
def halt(*response)
  response = response.first if response.length == 1
  throw :halt, response
end

# File lib/sinatra/base.rb, line 953
def options
  warn "Sinatra::Base#options is deprecated and will be removed, " \
    "use #settings instead."
  settings
end

# File lib/sinatra/base.rb, line 969
def pass(&block)
  throw :pass, block
end

# File lib/sinatra/base.rb, line 949
def settings
  self.class.settings
end

# File lib/sinatra/base.rb, line 1096
def dispatch!
  force_encoding(@params.merge!(@request.params))

  invoke do
    static! if settings.static? && (request.get? || request.head?)
    filter! :before
    route!
  end
rescue ::Exception => boom
  invoke { handle_exception!(boom) }
ensure
  begin
    filter! :after unless env['sinatra.static_file']
  rescue ::Exception => boom
    invoke { handle_exception!(boom) } unless @env['sinatra.error']
  end
end

# File lib/sinatra/base.rb, line 1164
def dump_errors!(boom)
  msg = ["#{Time.now.strftime("%Y-%m-%d %H:%M:%S")} - #{boom.class} - #{boom.message}:", *boom.backtrace].join("\n\t")
  @env['rack.errors'].puts(msg)
end

# File lib/sinatra/base.rb, line 1149
def error_block!(key, *block_params)
  base = settings
  while base.respond_to?(:errors)
    next base = base.superclass unless args_array = base.errors[key]
    args_array.reverse_each do |args|
      first = args == args_array.first
      args += [block_params]
      resp = process_route(*args)
      return resp unless resp.nil? && !first
    end
  end
  return false unless key.respond_to? :superclass and key.superclass < Exception
  error_block!(key.superclass, *block_params)
end

# File lib/sinatra/base.rb, line 986
def filter!(type, base = settings)
  filter! type, base.superclass if base.superclass.respond_to?(:filters)
  base.filters[type].each { |args| process_route(*args) }
end

# File lib/sinatra/base.rb, line 1757
def force_encoding(*args) settings.force_encoding(*args) end

# File lib/sinatra/base.rb, line 1115
def handle_exception!(boom)
  if error_params = @env['sinatra.error.params']
    @params = @params.merge(error_params)
  end
  @env['sinatra.error'] = boom

  if boom.respond_to? :http_status
    status(boom.http_status)
  elsif settings.use_code? and boom.respond_to? :code and boom.code.between? 400, 599
    status(boom.code)
  else
    status(500)
  end

  status(500) unless status.between? 400, 599

  boom_message = boom.message if boom.message && boom.message != boom.class.name
  if server_error?
    dump_errors! boom if settings.dump_errors?
    raise boom if settings.show_exceptions? and settings.show_exceptions != :after_handler
  elsif not_found?
    headers['X-Cascade'] = 'pass' if settings.x_cascade?
    body boom_message || '<h1>Not Found</h1>'
  elsif bad_request?
    body boom_message || '<h1>Bad Request</h1>'
  end

  res = error_block!(boom.class, boom) || error_block!(status, boom)
  return res if res or not server_error?
  raise boom if settings.raise_errors? or settings.show_exceptions?
  error_block! Exception, boom
end

# File lib/sinatra/base.rb, line 1080
def invoke
  res = catch(:halt) { yield }

  res = [res] if Integer === res or String === res
  if Array === res and Integer === res.first
    res = res.dup
    status(res.shift)
    body(res.pop)
    headers(*res)
  elsif res.respond_to? :each
    body res
  end
  nil # avoid double setting the same response tuple twice
end

# File lib/sinatra/base.rb, line 1024
def process_route(pattern, conditions, block = nil, values = [])
  route = @request.path_info
  route = '/' if route.empty? and not settings.empty_path_info?
  route = route[0..-2] if !settings.strict_paths? && route != '/' && route.end_with?('/')
  return unless params = pattern.params(route)

  params.delete("ignore") # TODO: better params handling, maybe turn it into "smart" object or detect changes
  force_encoding(params)
  original, @params = @params, @params.merge(params) if params.any?

  regexp_exists = pattern.is_a?(Mustermann::Regular) || (pattern.respond_to?(:patterns) && pattern.patterns.any? {|subpattern| subpattern.is_a?(Mustermann::Regular)} )
  if regexp_exists
    captures           = pattern.match(route).captures
    values            += captures
    @params[:captures] = force_encoding(captures) unless captures.nil? || captures.empty?
  else
    values += params.values.flatten
  end

  catch(:pass) do
    conditions.each { |c| throw :pass if c.bind(self).call == false }
    block ? block[self, values] : yield(self, values)
  end
rescue
  @env['sinatra.error.params'] = @params
  raise
ensure
  @params = original if original
end

# File lib/sinatra/base.rb, line 992
def route!(base = settings, pass_block = nil)
  if routes = base.routes[@request.request_method]
    routes.each do |pattern, conditions, block|
      returned_pass_block = process_route(pattern, conditions) do |*args|
        env['sinatra.route'] = "#{@request.request_method} #{pattern}"
        route_eval { block[*args] }
      end

      # don't wipe out pass_block in superclass
      pass_block = returned_pass_block if returned_pass_block
    end
  end

  # Run routes defined in superclass.
  if base.superclass.respond_to?(:routes)
    return route!(base.superclass, pass_block)
  end

  route_eval(&pass_block) if pass_block
  route_missing
end

# File lib/sinatra/base.rb, line 1015
def route_eval
  throw :halt, yield
end

# File lib/sinatra/base.rb, line 1059
def route_missing
  if @app
    forward
  else
    raise NotFound
  end
end

# File lib/sinatra/base.rb, line 1069
def static!(options = {})
  return if (public_dir = settings.public_folder).nil?
  path = File.expand_path("#{public_dir}#{URI_INSTANCE.unescape(request.path_info)}" )
  return unless File.file?(path)

  env['sinatra.static_file'] = path
  cache_control(*settings.static_cache_control) if settings.static_cache_control?
  send_file path, options.merge(:disposition => nil)
end