scout_realtime 0.5.1

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/respond_with.rb

@@ -0,0 +1,247 @@
+require 'sinatra/json'
+require 'sinatra/base'
+
+module Sinatra
+  #
+  # = Sinatra::RespondWith
+  #
+  # These extensions let Sinatra automatically choose what template to render or
+  # action to perform depending on the request's Accept header.
+  #
+  # Example:
+  #
+  #   # Without Sinatra::RespondWith
+  #   get '/' do
+  #     data = { :name => 'example' }
+  #     request.accept.each do |type|
+  #       case type.to_s
+  #       when 'text/html'
+  #         halt haml(:index, :locals => data)
+  #       when 'text/json'
+  #         halt data.to_json
+  #       when 'application/atom+xml'
+  #         halt nokogiri(:'index.atom', :locals => data)
+  #       when 'application/xml', 'text/xml'
+  #         halt nokogiri(:'index.xml', :locals => data)
+  #       when 'text/plain'
+  #         halt 'just an example'
+  #       end
+  #     end
+  #     error 406
+  #   end
+  #
+  #   # With Sinatra::RespondWith
+  #   get '/' do
+  #     respond_with :index, :name => 'example' do |f|
+  #       f.txt { 'just an example' }
+  #     end
+  #   end
+  #
+  # Both helper methods +respond_to+ and +respond_with+ let you define custom
+  # handlers like the one above for +text/plain+. +respond_with+ additionally
+  # takes a template name and/or an object to offer the following default
+  # behavior:
+  #
+  # * If a template name is given, search for a template called
+  #   +name.format.engine+ (+index.xml.nokogiri+ in the above example).
+  # * If a template name is given, search for a templated called +name.engine+
+  #   for engines known to result in the requested format (+index.haml+).
+  # * If a file extension associated with the mime type is known to Sinatra, and
+  #   the object responds to +to_extension+, call that method and use the result
+  #   (+data.to_json+).
+  #
+  # == Security
+  #
+  # Since methods are triggered based on client input, this can lead to security
+  # issues (but not as severe as those might appear in the first place: keep in
+  # mind that only known file extensions are used). You should limit
+  # the possible formats you serve.
+  #
+  # This is possible with the +provides+ condition:
+  #
+  #   get '/', :provides => [:html, :json, :xml, :atom] do
+  #     respond_with :index, :name => 'example'
+  #   end
+  #
+  # However, since you have to set +provides+ for every route, this extension
+  # adds an app global (class method) `respond_to`, that lets you define content
+  # types for all routes:
+  #
+  #   respond_to :html, :json, :xml, :atom
+  #   get('/a') { respond_with :index, :name => 'a' }
+  #   get('/b') { respond_with :index, :name => 'b' }
+  #
+  # == Custom Types
+  #
+  # Use the +on+ method for defining actions for custom types:
+  #
+  #   get '/' do
+  #     respond_to do |f|
+  #       f.xml { nokogiri :index }
+  #       f.on('application/custom') { custom_action }
+  #       f.on('text/*') { data.to_s }
+  #       f.on('*/*') { "matches everything" }
+  #     end
+  #   end
+  #
+  # Definition order does not matter.
+  module RespondWith
+    class Format
+      def initialize(app)
+        @app, @map, @generic, @default = app, {}, {}, nil
+      end
+
+      def on(type, &block)
+        @app.settings.mime_types(type).each do |mime|
+          case mime
+          when '*/*'            then @default     = block
+          when /^([^\/]+)\/\*$/ then @generic[$1] = block
+          else                       @map[mime]   = block
+          end
+        end
+      end
+
+      def finish
+        yield self if block_given?
+        mime_type = @app.content_type             ||
+          @app.request.preferred_type(@map.keys)  ||
+          @app.request.preferred_type             ||
+          'text/html'
+        type = mime_type.split(/\s*;\s*/, 2).first
+        handlers = [@map[type], @generic[type[/^[^\/]+/]], @default].compact
+        handlers.each do |block|
+          if result = block.call(type)
+            @app.content_type mime_type
+            @app.halt result
+          end
+        end
+        @app.halt 406
+      end
+
+      def method_missing(method, *args, &block)
+        return super if args.any? or block.nil? or not @app.mime_type(method)
+        on(method, &block)
+      end
+    end
+
+    module Helpers
+      include Sinatra::JSON
+
+      def respond_with(template, object = nil, &block)
+        object, template = template, nil unless Symbol === template
+        format = Format.new(self)
+        format.on "*/*" do |type|
+          exts = settings.ext_map[type]
+          exts << :xml if type.end_with? '+xml'
+          if template
+            args = template_cache.fetch(type, template) { template_for(template, exts) }
+            if args.any?
+              locals = { :object => object }
+              locals.merge! object.to_hash if object.respond_to? :to_hash
+
+              renderer = args.first
+              options = args[1..-1] + [{:locals => locals}]
+
+              halt send(renderer, *options)
+            end
+          end
+          if object
+            exts.each do |ext|
+              halt json(object) if ext == :json
+              next unless object.respond_to? method = "to_#{ext}"
+              halt(*object.send(method))
+            end
+          end
+          false
+        end
+        format.finish(&block)
+      end
+
+      def respond_to(&block)
+        Format.new(self).finish(&block)
+      end
+
+      private
+
+      def template_for(name, exts)
+        # in production this is cached, so don't worry too much about runtime
+        possible = []
+        settings.template_engines[:all].each do |engine|
+          exts.each { |ext| possible << [engine, "#{name}.#{ext}"] }
+        end
+        exts.each do |ext|
+          settings.template_engines[ext].each { |e| possible << [e, name] }
+        end
+        possible.each do |engine, template|
+          # not exactly like Tilt[engine], but does not trigger a require
+          klass = Tilt.mappings[Tilt.normalize(engine)].first
+          find_template(settings.views, template, klass) do |file|
+            next unless File.exist? file
+            return settings.rendering_method(engine) << template.to_sym
+          end
+        end
+        [] # nil or false would not be cached
+      end
+    end
+
+    def remap_extensions
+      ext_map.clear
+      Rack::Mime::MIME_TYPES.each { |e,t| ext_map[t] << e[1..-1].to_sym }
+      ext_map['text/javascript'] << 'js'
+      ext_map['text/xml'] << 'xml'
+    end
+
+    def mime_type(*)
+      result = super
+      remap_extensions
+      result
+    end
+
+    def respond_to(*formats)
+      if formats.any?
+        @respond_to ||= []
+        @respond_to.concat formats
+      elsif @respond_to.nil? and superclass.respond_to? :respond_to
+        superclass.respond_to
+      else
+        @respond_to
+      end
+    end
+
+    def rendering_method(engine)
+      return [engine] if Sinatra::Templates.method_defined? engine
+      return [:mab] if engine.to_sym == :markaby
+      [:render, :engine]
+    end
+
+    private
+
+    def compile!(verb, path, block, options = {})
+      options[:provides] ||= respond_to if respond_to
+      super
+    end
+
+    ENGINES = {
+      :css  => [:less,  :sass, :scss],
+      :xml  => [:builder, :nokogiri],
+      :js   => [:coffee],
+      :json => [:yajl],
+      :html => [:erb, :erubis, :haml, :slim, :liquid, :radius, :mab, :markdown,
+        :textile, :rdoc],
+      :all  => Sinatra::Templates.instance_methods.map(&:to_sym) + [:mab] -
+        [:find_template, :markaby]
+    }
+
+    ENGINES.default = []
+
+    def self.registered(base)
+      base.set :ext_map, Hash.new { |h,k| h[k] = [] }
+      base.set :template_engines, ENGINES.dup
+      base.remap_extensions
+      base.helpers Helpers
+    end
+  end
+
+  register RespondWith
+  Delegator.delegate :respond_to
+end

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/streaming.rb

@@ -0,0 +1,243 @@
+require 'sinatra/base'
+require 'backports'
+
+module Sinatra
+
+  # = Sinatra::Streaming
+  #
+  # Sinatra 1.3 introduced the +stream+ helper. This addon improves the
+  # streaming API by making the stream object immitate an IO object, turning
+  # it into a real Deferrable and making the body play nicer with middleware
+  # unaware of streaming.
+  #
+  # == IO-like behavior
+  #
+  # This is useful when passing the stream object to a library expecting an
+  # IO or StringIO object.
+  #
+  #   get '/' do
+  #     stream do |out|
+  #       out.puts "Hello World!", "How are you?"
+  #       out.write "Written #{out.pos} bytes so far!\n"
+  #       out.putc(65) unless out.closed?
+  #       out.flush
+  #     end
+  #   end
+  #
+  # == Better Middleware Handling
+  #
+  # Blocks passed to #map! or #map will actually be applied when streaming
+  # takes place (as you might have suspected, #map! applies modifications
+  # to the current body, while #map creates a new one):
+  #
+  #   class StupidMiddleware
+  #     def initialize(app) @app = app end
+  #
+  #     def call(env)
+  #       status, headers, body = @app.call(env)
+  #       body.map! { |e| e.upcase }
+  #       [status, headers, body]
+  #     end
+  #   end
+  #
+  #   use StupidMiddleware
+  #
+  #   get '/' do
+  #     stream do |out|
+  #       out.puts "still"
+  #       sleep 1
+  #       out.puts "streaming"
+  #     end
+  #   end
+  #
+  # Even works if #each is used to generate an Enumerator:
+  #
+  #   def call(env)
+  #     status, headers, body = @app.call(env)
+  #     body = body.each.map { |s| s.upcase }
+  #     [status, headers, body]
+  #   end
+  #
+  # Note that both examples violate the Rack specification.
+  #
+  # == Setup
+  #
+  # In a classic application:
+  #
+  #   require "sinatra"
+  #   require "sinatra/streaming"
+  #
+  # In a modular application:
+  #
+  #   require "sinatra/base"
+  #   require "sinatra/streaming"
+  #
+  #   class MyApp < Sinatra::Base
+  #     helpers Sinatra::Streaming
+  #   end
+  module Streaming
+    def stream(*)
+      stream = super
+      stream.extend Stream
+      stream.app = self
+      env['async.close'].callback { stream.close } if env.key? 'async.close'
+      stream
+    end
+
+    module Stream
+
+      attr_accessor :app, :lineno, :pos, :transformer, :closed
+      alias tell pos
+      alias closed? closed
+
+      def self.extended(obj)
+        obj.closed, obj.lineno, obj.pos = false, 0, 0
+        obj.callback { obj.closed = true }
+        obj.errback  { obj.closed = true }
+      end
+
+      def <<(data)
+        raise IOError, 'not opened for writing' if closed?
+        data = data.to_s
+        data = @transformer[data] if @transformer
+        @pos += data.bytesize
+        super(data)
+      end
+
+      def each
+        # that way body.each.map { ... } works
+        return self unless block_given?
+        super
+      end
+
+      def map(&block)
+        # dup would not copy the mixin
+        clone.map!(&block)
+      end
+
+      def map!(&block)
+        if @transformer
+          inner, outer = @transformer, block
+          block = proc { |value| outer[inner[value]] }
+        end
+        @transformer = block
+        self
+      end
+
+      def write(data)
+        self << data
+        data.to_s.bytesize
+      end
+
+      alias syswrite      write
+      alias write_nonblock write
+
+      def print(*args)
+        args.each { |arg| self << arg }
+        nil
+      end
+
+      def printf(format, *args)
+        print(format.to_s % args)
+      end
+
+      def putc(c)
+        print c.chr
+      end
+
+      def puts(*args)
+        args.each { |arg| self << "#{arg}\n" }
+        nil
+      end
+
+      def close_read
+        raise IOError, "closing non-duplex IO for reading"
+      end
+
+      def closed_read?
+        true
+      end
+
+      def closed_write?
+        closed?
+      end
+
+      def external_encoding
+        Encoding.find settings.default_encoding
+      rescue NameError
+        settings.default_encoding
+      end
+
+      def closed?
+        @closed
+      end
+
+      def settings
+        app.settings
+      end
+
+      def rewind
+        @pos = @lineno = 0
+      end
+
+      def not_open_for_reading(*)
+        raise IOError, "not opened for reading"
+      end
+
+      alias bytes         not_open_for_reading
+      alias eof?          not_open_for_reading
+      alias eof           not_open_for_reading
+      alias getbyte       not_open_for_reading
+      alias getc          not_open_for_reading
+      alias gets          not_open_for_reading
+      alias read          not_open_for_reading
+      alias read_nonblock not_open_for_reading
+      alias readbyte      not_open_for_reading
+      alias readchar      not_open_for_reading
+      alias readline      not_open_for_reading
+      alias readlines     not_open_for_reading
+      alias readpartial   not_open_for_reading
+      alias sysread       not_open_for_reading
+      alias ungetbyte     not_open_for_reading
+      alias ungetc        not_open_for_reading
+      private :not_open_for_reading
+
+      def enum_not_open_for_reading(*)
+        not_open_for_reading if block_given?
+        enum_for(:not_open_for_reading)
+      end
+
+      alias chars     enum_not_open_for_reading
+      alias each_line enum_not_open_for_reading
+      alias each_byte enum_not_open_for_reading
+      alias each_char enum_not_open_for_reading
+      alias lines     enum_not_open_for_reading
+      undef enum_not_open_for_reading
+
+      def dummy(*) end
+      alias flush             dummy
+      alias fsync             dummy
+      alias internal_encoding dummy
+      alias pid               dummy
+      undef dummy
+
+      def seek(*)
+        0
+      end
+
+      alias sysseek seek
+
+      def sync
+        true
+      end
+
+      def tty?
+        false
+      end
+
+      alias isatty tty?
+    end
+  end
+
+  helpers Streaming
+end

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/test_helpers.rb

@@ -0,0 +1,87 @@
+require 'sinatra/base'
+require 'rack/test'
+require 'rack'
+require 'forwardable'
+
+module Sinatra
+  Base.set :environment, :test
+
+  module TestHelpers
+    class Session < Rack::Test::Session
+      def global_env
+        @global_env ||= {}
+      end
+
+      private
+
+      def default_env
+        super.merge global_env
+      end
+    end
+
+    include Rack::Test::Methods
+    extend Forwardable
+    attr_accessor :settings
+
+    def_delegators :last_response, :body, :headers, :status, :errors
+    def_delegators :app, :configure, :set, :enable, :disable, :use, :helpers, :register
+    def_delegators :current_session, :env_for
+    def_delegators :rack_mock_session, :cookie_jar
+
+    def mock_app(base = Sinatra::Base, &block)
+      inner = nil
+      @app  = Sinatra.new(base) do
+        inner = self
+        class_eval(&block)
+      end
+      @settings = inner
+      app
+    end
+
+    def app=(base)
+      @app = base
+    end
+
+    alias set_app app=
+
+    def app
+      @app ||= Class.new Sinatra::Base
+      Rack::Lint.new @app
+    end
+
+    unless method_defined? :options
+      def options(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "OPTIONS", :params => params))
+        current_session.send(:process_request, uri, env, &block)
+      end
+    end
+
+    unless method_defined? :patch
+      def patch(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "PATCH", :params => params))
+        current_session.send(:process_request, uri, env, &block)
+      end
+    end
+
+    def last_request?
+      last_request
+      true
+    rescue Rack::Test::Error
+      false
+    end
+
+    def session
+      return {} unless last_request?
+      raise Rack::Test::Error, "session not enabled for app" unless last_env["rack.session"] or app.session?
+      last_request.session
+    end
+
+    def last_env
+      last_request.env
+    end
+
+    def build_rack_test_session(name) # :nodoc:
+      Session.new rack_mock_session(name)
+    end
+  end
+end

data/lib/vendor/tilt-1.4.1/lib/tilt/asciidoc.rb

@@ -0,0 +1,34 @@
+require 'tilt/template'
+
+# AsciiDoc see: http://asciidoc.org/
+module Tilt
+  # Asciidoctor implementation for AsciiDoc see:
+  # http://asciidoctor.github.com/
+  #
+  # Asciidoctor is an open source, pure-Ruby processor for
+  # converting AsciiDoc documents or strings into HTML 5,
+  # DocBook 4.5 and other formats.
+  class AsciidoctorTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::Asciidoctor::Document
+    end
+
+    def initialize_engine
+      require_template_library 'asciidoctor'
+    end
+
+    def prepare
+      options[:header_footer] = false if options[:header_footer].nil?
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= Asciidoctor.render(data, options, &block)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/lib/vendor/tilt-1.4.1/lib/tilt/builder.rb

@@ -0,0 +1,40 @@
+require 'tilt/template'
+
+module Tilt
+   # Builder template implementation. See:
+  # http://builder.rubyforge.org/
+  class BuilderTemplate < Template
+    self.default_mime_type = 'text/xml'
+
+    def self.engine_initialized?
+      defined? ::Builder
+    end
+
+    def initialize_engine
+      require_template_library 'builder'
+    end
+
+    def prepare; end
+
+    def evaluate(scope, locals, &block)
+      return super(scope, locals, &block) if data.respond_to?(:to_str)
+      xml = ::Builder::XmlMarkup.new(:indent => 2)
+      data.call(xml)
+      xml.target!
+    end
+
+    def precompiled_preamble(locals)
+      return super if locals.include? :xml
+      "xml = ::Builder::XmlMarkup.new(:indent => 2)\n#{super}"
+    end
+
+    def precompiled_postamble(locals)
+      "xml.target!"
+    end
+
+    def precompiled_template(locals)
+      data.to_str
+    end
+  end
+end
+

data/lib/vendor/tilt-1.4.1/lib/tilt/coffee.rb

@@ -0,0 +1,54 @@
+require 'tilt/template'
+
+module Tilt
+  # CoffeeScript template implementation. See:
+  # http://coffeescript.org/
+  #
+  # CoffeeScript templates do not support object scopes, locals, or yield.
+  class CoffeeScriptTemplate < Template
+    self.default_mime_type = 'application/javascript'
+
+    @@default_bare = false
+
+    def self.default_bare
+      @@default_bare
+    end
+
+    def self.default_bare=(value)
+      @@default_bare = value
+    end
+
+    # DEPRECATED
+    def self.default_no_wrap
+      @@default_bare
+    end
+
+    # DEPRECATED
+    def self.default_no_wrap=(value)
+      @@default_bare = value
+    end
+
+    def self.engine_initialized?
+      defined? ::CoffeeScript
+    end
+
+    def initialize_engine
+      require_template_library 'coffee_script'
+    end
+
+    def prepare
+      if !options.key?(:bare) and !options.key?(:no_wrap)
+        options[:bare] = self.class.default_bare
+      end
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= CoffeeScript.compile(data, options)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+