RubyGems - scout_realtime - Versions diffs - 0.5.1 - Mend

scout_realtime 0.5.1

Files changed (563) hide show

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/content_for.rb ADDED Viewed

@@ -0,0 +1,125 @@
+require 'sinatra/base'
+require 'sinatra/capture'
+module Sinatra
+  # = Sinatra::ContentFor
+  #
+  # <tt>Sinatra::ContentFor</tt> is a set of helpers that allows you to capture
+  # blocks inside views to be rendered later during the request. The most
+  # common use is to populate different parts of your layout from your view.
+  #
+  # The currently supported engines are: Erb, Erubis, Haml and Slim.
+  #
+  # == Usage
+  #
+  # You call +content_for+, generally from a view, to capture a block of markup
+  # giving it an identifier:
+  #
+  #     # index.erb
+  #     <% content_for :some_key do %>
+  #       <chunk of="html">...</chunk>
+  #     <% end %>
+  #
+  # Then, you call +yield_content+ with that identifier, generally from a
+  # layout, to render the captured block:
+  #
+  #     # layout.erb
+  #     <%= yield_content :some_key %>
+  #
+  # === Classic Application
+  #
+  # To use the helpers in a classic application all you need to do is require
+  # them:
+  #
+  #     require "sinatra"
+  #     require "sinatra/content_for"
+  #
+  #     # Your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # To use the helpers in a modular application you need to require them, and
+  # then, tell the application you will use them:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/content_for"
+  #
+  #     class MyApp < Sinatra::Base
+  #       helpers Sinatra::ContentFor
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  # == And How Is This Useful?
+  #
+  # For example, some of your views might need a few javascript tags and
+  # stylesheets, but you don't want to force this files in all your pages.
+  # Then you can put <tt><% yield_content :scripts_and_styles %></tt> on your
+  # layout, inside the <head> tag, and each view can call <tt>content_for</tt>
+  # setting the appropriate set of tags that should be added to the layout.
+  #
+  module ContentFor
+    include Capture
+    # Capture a block of content to be rendered later. For example:
+    #
+    #     <% content_for :head do %>
+    #       <script type="text/javascript" src="/foo.js"></script>
+    #     <% end %>
+    #
+    # You can call +content_for+ multiple times with the same key
+    # (in the example +:head+), and when you render the blocks for
+    # that key all of them will be rendered, in the same order you
+    # captured them.
+    #
+    # Your blocks can also receive values, which are passed to them
+    # by <tt>yield_content</tt>
+    def content_for(key, &block)
+      content_blocks[key.to_sym] << capture_later(&block)
+    end
+    # Check if a block of content with the given key was defined. For
+    # example:
+    #
+    #     <% content_for :head do %>
+    #       <script type="text/javascript" src="/foo.js"></script>
+    #     <% end %>
+    #
+    #     <% if content_for? :head %>
+    #       <span>content "head" was defined.</span>
+    #     <% end %>
+    def content_for?(key)
+      content_blocks[key.to_sym].any?
+    end
+    # Render the captured blocks for a given key. For example:
+    #
+    #     <head>
+    #       <title>Example</title>
+    #       <%= yield_content :head %>
+    #     </head>
+    #
+    # Would render everything you declared with <tt>content_for
+    # :head</tt> before closing the <tt><head></tt> tag.
+    #
+    # You can also pass values to the content blocks by passing them
+    # as arguments after the key:
+    #
+    #     <%= yield_content :head, 1, 2 %>
+    #
+    # Would pass <tt>1</tt> and <tt>2</tt> to all the blocks registered
+    # for <tt>:head</tt>.
+    def yield_content(key, *args)
+      content_blocks[key.to_sym].map { |b| capture(*args, &b) }.join
+    end
+    private
+    def content_blocks
+      @content_blocks ||= Hash.new {|h,k| h[k] = [] }
+    end
+  end
+  helpers ContentFor
+end

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/contrib/all.rb ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ require 'sinatra/contrib'
2	+ Sinatra.register Sinatra::Contrib::All

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/contrib/setup.rb ADDED Viewed

@@ -0,0 +1,53 @@
+require 'sinatra/base'
+require 'sinatra/contrib/version'
+require 'backports'
+module Sinatra
+  module Contrib
+    module Loader
+      def extensions
+        @extensions ||= {:helpers => [], :register => []}
+      end
+      def register(name, path = nil)
+        autoload name, path, :register
+      end
+      def helpers(name, path = nil)
+        autoload name, path, :helpers
+      end
+      def autoload(name, path = nil, method = nil)
+        path ||= "sinatra/#{name.to_s.underscore}"
+        extensions[method] << name if method
+        Sinatra.autoload(name, path)
+      end
+      def registered(base)
+        @extensions.each do |method, list|
+          list = list.map { |name| Sinatra.const_get name }
+          base.send(method, *list) unless base == ::Sinatra::Application
+        end
+      end
+    end
+    module Common
+      extend Loader
+    end
+    module Custom
+      extend Loader
+    end
+    module All
+      def self.registered(base)
+        base.register Common, Custom
+      end
+    end
+    extend Loader
+    def self.registered(base)
+      base.register Common, Custom
+    end
+  end
+end

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/contrib/version.rb ADDED Viewed

@@ -0,0 +1,17 @@
+module Sinatra
+  module Contrib
+    def self.version
+      VERSION
+    end
+    SIGNATURE = [1, 4, 1]
+    VERSION   = SIGNATURE.join('.')
+    VERSION.extend Comparable
+    def VERSION.<=>(other)
+      other = other.split('.').map { |i| i.to_i } if other.respond_to? :split
+      SIGNATURE <=> Array(other)
+    end
+  end
+end

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/contrib.rb ADDED Viewed

@@ -0,0 +1,39 @@
+require 'sinatra/contrib/setup'
+module Sinatra
+  module Contrib
+    ##
+    # Common middleware that doesn't bring run time overhead if not used
+    # or breaks if external dependencies are missing. Will extend
+    # Sinatra::Application by default.
+    module Common
+      register :ConfigFile
+      register :MultiRoute
+      register :Namespace
+      register :RespondWith
+      helpers :Capture
+      helpers :ContentFor
+      helpers :Cookies
+      helpers :EngineTracking
+      helpers :JSON
+      helpers :LinkHeader
+      helpers :Streaming
+    end
+    ##
+    # Other extensions you don't want to be loaded unless needed.
+    module Custom
+      # register :Compass
+      register :Decompile
+      register :Reloader
+    end
+    ##
+    # Stuff that aren't Sinatra extensions, technically.
+    autoload :Extension
+    autoload :TestHelpers
+  end
+  register Sinatra::Contrib::Common
+end

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/cookies.rb ADDED Viewed

@@ -0,0 +1,331 @@
+require 'sinatra/base'
+require 'backports'
+module Sinatra
+  # = Sinatra::Cookies
+  #
+  # Easy way to deal with cookies
+  #
+  # == Usage
+  #
+  # Allows you to read cookies:
+  #
+  #   get '/' do
+  #     "value: #{cookies[:something]}"
+  #   end
+  #
+  # And of course to write cookies:
+  #
+  #   get '/set' do
+  #     cookies[:something] = 'foobar'
+  #     redirect to('/')
+  #   end
+  #
+  # And generally behaves like a hash:
+  #
+  #   get '/demo' do
+  #     cookies.merge! 'foo' => 'bar', 'bar' => 'baz'
+  #     cookies.keep_if { |key, value| key.start_with? 'b' }
+  #     foo, bar = cookies.values_at 'foo', 'bar'
+  #     "size: #{cookies.length}"
+  #   end
+  #
+  # === Classic Application
+  #
+  # In a classic application simply require the helpers, and start using them:
+  #
+  #     require "sinatra"
+  #     require "sinatra/cookies"
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # In a modular application you need to require the helpers, and then tell
+  # the application to use them:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/cookies"
+  #
+  #     class MyApp < Sinatra::Base
+  #       helpers Sinatra::Cookies
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  module Cookies
+    class Jar
+      include Enumerable
+      attr_reader :options
+      def initialize(app)
+        @response_string = nil
+        @response_hash   = {}
+        @response        = app.response
+        @request         = app.request
+        @deleted         = []
+        @options = {
+          :path     => @request.script_name,
+          :domain   => @request.host,
+          :secure   => @request.secure?,
+          :httponly => true
+        }
+        @options[:path] = '/' if @options[:path].to_s.empty?
+        if app.settings.respond_to? :cookie_options
+          @options.merge! app.settings.cookie_options
+        end
+      end
+      def ==(other)
+        other.respond_to? :to_hash and to_hash == other.to_hash
+      end
+      def [](key)
+        response_cookies[key.to_s] || request_cookies[key.to_s]
+      end
+      def []=(key, value)
+        @response.set_cookie key.to_s, @options.merge(:value => value)
+      end
+      def assoc(key)
+        to_hash.assoc(key.to_s)
+      end if Hash.method_defined? :assoc
+      def clear
+        each_key { |k| delete(k) }
+      end
+      def compare_by_identity?
+        false
+      end
+      def default
+        nil
+      end
+      alias default_proc default
+      def delete(key)
+        result = self[key]
+        @response.delete_cookie(key.to_s, @options)
+        result
+      end
+      def delete_if
+        return enum_for(__method__) unless block_given?
+        each { |k, v| delete(k) if yield(k, v) }
+        self
+      end
+      def each(&block)
+        return enum_for(__method__) unless block_given?
+        to_hash.each(&block)
+      end
+      def each_key(&block)
+        return enum_for(__method__) unless block_given?
+        to_hash.each_key(&block)
+      end
+      alias each_pair each
+      def each_value(&block)
+        return enum_for(__method__) unless block_given?
+        to_hash.each_value(&block)
+      end
+      def empty?
+        to_hash.empty?
+      end
+      def fetch(key, &block)
+        response_cookies.fetch(key.to_s) do
+          request_cookies.fetch(key.to_s, &block)
+        end
+      end
+      def flatten
+        to_hash.flatten
+      end if Hash.method_defined? :flatten
+      def has_key?(key)
+        response_cookies.has_key? key.to_s or request_cookies.has_key? key.to_s
+      end
+      def has_value?(value)
+        response_cookies.has_value? value or request_cookies.has_value? value
+      end
+      def hash
+        to_hash.hash
+      end
+      alias include? has_key?
+      alias member?  has_key?
+      def index(value)
+        warn "Hash#index is deprecated; use Hash#key" if RUBY_VERSION > '1.9'
+        key(value)
+      end
+      def inspect
+        "<##{self.class}: #{to_hash.inspect[1..-2]}>"
+      end
+      def invert
+        to_hash.invert
+      end if Hash.method_defined? :invert
+      def keep_if
+        return enum_for(__method__) unless block_given?
+        delete_if { |*a| not yield(*a) }
+      end
+      def key(value)
+        to_hash.key(value)
+      end
+      alias key? has_key?
+      def keys
+        to_hash.keys
+      end
+      def length
+        to_hash.length
+      end
+      def merge(other, &block)
+        to_hash.merge(other, &block)
+      end
+      def merge!(other)
+        other.each_pair do |key, value|
+          if block_given? and include? key
+            self[key] = yield(key.to_s, self[key], value)
+          else
+            self[key] = value
+          end
+        end
+      end
+      def rassoc(value)
+        to_hash.rassoc(value)
+      end
+      def rehash
+        response_cookies.rehash
+        request_cookies.rehash
+        self
+      end
+      def reject(&block)
+        return enum_for(__method__) unless block_given?
+        to_hash.reject(&block)
+      end
+      alias reject! delete_if
+      def replace(other)
+        select! { |k, v| other.include?(k) or other.include?(k.to_s)  }
+        merge! other
+      end
+      def select(&block)
+        return enum_for(__method__) unless block_given?
+        to_hash.select(&block)
+      end
+      alias select! keep_if if Hash.method_defined? :select!
+      def shift
+        key, value = to_hash.shift
+        delete(key)
+        [key, value]
+      end
+      alias size length
+      def sort(&block)
+        to_hash.sort(&block)
+      end if Hash.method_defined? :sort
+      alias store []=
+      def to_hash
+        request_cookies.merge(response_cookies)
+      end
+      def to_a
+        to_hash.to_a
+      end
+      def to_s
+        to_hash.to_s
+      end
+      alias update merge!
+      alias value? has_value?
+      def values
+        to_hash.values
+      end
+      def values_at(*list)
+        list.map { |k| self[k] }
+      end
+      private
+      def warn(message)
+        super "#{caller.first[/^[^:]:\d+:/]} warning: #{message}"
+      end
+      def deleted
+        parse_response
+        @deleted
+      end
+      def response_cookies
+        parse_response
+        @response_hash
+      end
+      def parse_response
+        string = @response['Set-Cookie']
+        return if @response_string == string
+        hash = {}
+        string.each_line do |line|
+          key, value = line.split(';', 2).first.to_s.split('=', 2)
+          next if key.nil?
+          key = Rack::Utils.unescape(key)
+          if line =~ /expires=Thu, 01[-\s]Jan[-\s]1970/
+            @deleted << key
+          else
+            @deleted.delete key
+            hash[key] = value
+          end
+        end
+        @response_hash.replace hash
+        @response_string = string
+      end
+      def request_cookies
+        @request.cookies.reject { |key, value| deleted.include? key }
+      end
+    end
+    def cookies
+      @cookies ||= Jar.new(self)
+    end
+  end
+  helpers Cookies
+end

data/lib/vendor/sinatra-contrib-1.4.1/lib/sinatra/decompile.rb ADDED Viewed

@@ -0,0 +1,121 @@
+require 'sinatra/base'
+require 'backports'
+require 'uri'
+module Sinatra
+  # = Sinatra::Decompile
+  #
+  # <tt>Sinatra::Decompile</tt> is an extension that provides a method,
+  # conveniently called +decompile+, that will generate a String pattern for a
+  # given route.
+  #
+  # == Usage
+  #
+  # === Classic Application
+  #
+  # To use the extension in a classic application all you need to do is require
+  # it:
+  #
+  #     require "sinatra"
+  #     require "sinatra/decompile"
+  #
+  #     # Your classic application code goes here...
+  #
+  # This will add the +decompile+ method to the application/class scope, but
+  # you can also call it as <tt>Sinatra::Decompile.decompile</tt>.
+  #
+  # === Modular Application
+  #
+  # To use the extension in a modular application you need to require it, and
+  # then, tell the application you will use it:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/decompile"
+  #
+  #     class MyApp < Sinatra::Base
+  #       register Sinatra::Decompile
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  # This will add the +decompile+ method to the application/class scope.  You
+  # can choose not to register the extension, but instead of calling
+  # +decompile+, you will need to call <tt>Sinatra::Decompile.decompile</tt>.
+  #
+  module Decompile
+    extend self
+    ##
+    # Regenerates a string pattern for a given route
+    #
+    # Example:
+    #
+    #   class Sinatra::Application
+    #     routes.each do |verb, list|
+    #       puts "#{verb}:"
+    #       list.each do |data|
+    #         puts "\t" << decompile(data)
+    #       end
+    #     end
+    #   end
+    #
+    # Will return the internal Regexp if it's unable to reconstruct the pattern,
+    # which likely indicates that a Regexp was used in the first place.
+    #
+    # You can also use this to check whether you could actually use a string
+    # pattern instead of your regexp:
+    #
+    #   decompile /^/foo$/ # => '/foo'
+    def decompile(pattern, keys = nil, *)
+      # Everything in here is basically just the reverse of
+      # Sinatra::Base#compile
+      #
+      # Sinatra 2.0 will come with a mechanism for this, making this obsolete.
+      pattern, keys = pattern if pattern.respond_to? :to_ary
+      keys, str     = keys.try(:dup), pattern.inspect
+      return pattern unless str.start_with? '/' and str.end_with? '/'
+      str.gsub! /^\/(\^|\\A)?|(\$|\\z)?\/$/, ''
+      str.gsub! encoded(' '), ' '
+      return pattern if str =~ /^[\.\+]/
+      str.gsub! '((?:[^\.\/?#%]|(?:%[^2].|%[2][^Ee]))+)', '([^\/?#]+)'
+      str.gsub! '((?:[^\/?#%]|(?:%[^2].|%[2][^Ee]))+)', '([^\/?#]+)'
+      str.gsub! /\([^\(\)]*\)|\([^\(\)]*\([^\(\)]*\)[^\(\)]*\)/ do |part|
+        case part
+        when '(.*?)'
+          return pattern if keys.shift != 'splat'
+          '*'
+        when /^\(\?\:(\\*.)\|%[\w\[\]]+\)$/
+          $1
+        when /^\(\?\:(%\d+)\|([^\)]+|\([^\)]+\))\)$/
+          URI.unescape($1)
+        when '([^\/?#]+)'
+          return pattern if keys.empty?
+          ":" << keys.shift
+        when /^\(\?\:\\?(.)\|/
+          char = $1
+          return pattern unless encoded(char) == part
+          Regexp.escape(char)
+        else
+          return pattern
+        end
+      end
+      str.gsub /(.)([\.\+\(\)\/])/ do
+        return pattern if $1 != "\\"
+        $2
+      end
+    end
+    private
+    def encoded(char)
+      return super if defined? super
+      enc = URI.escape(char)
+      enc = "(?:#{escaped(char, enc).join('|')})" if enc == char
+      enc = "(?:#{enc}|#{encoded('+')})" if char == " "
+      enc
+    end
+  end
+  register Decompile
+end