RubyGems - sinatra-contrib - Versions diffs - 1.3.0 - Mend

sinatra-contrib 1.3.0

Files changed (79) hide show

data/LICENSE +20 -0
data/README.md +135 -0
data/Rakefile +75 -0
data/ideas.md +29 -0
data/lib/sinatra/capture.rb +42 -0
data/lib/sinatra/config_file.rb +151 -0
data/lib/sinatra/content_for.rb +111 -0
data/lib/sinatra/contrib.rb +39 -0
data/lib/sinatra/contrib/all.rb +2 -0
data/lib/sinatra/contrib/setup.rb +53 -0
data/lib/sinatra/contrib/version.rb +45 -0
data/lib/sinatra/cookies.rb +331 -0
data/lib/sinatra/decompile.rb +113 -0
data/lib/sinatra/engine_tracking.rb +96 -0
data/lib/sinatra/extension.rb +95 -0
data/lib/sinatra/json.rb +134 -0
data/lib/sinatra/link_header.rb +132 -0
data/lib/sinatra/multi_route.rb +81 -0
data/lib/sinatra/namespace.rb +282 -0
data/lib/sinatra/reloader.rb +384 -0
data/lib/sinatra/respond_with.rb +245 -0
data/lib/sinatra/streaming.rb +267 -0
data/lib/sinatra/test_helpers.rb +87 -0
data/sinatra-contrib.gemspec +125 -0
data/spec/capture_spec.rb +80 -0
data/spec/config_file/key_value.yml +6 -0
data/spec/config_file/missing_env.yml +4 -0
data/spec/config_file/with_envs.yml +7 -0
data/spec/config_file/with_nested_envs.yml +11 -0
data/spec/config_file_spec.rb +44 -0
data/spec/content_for/different_key.erb +1 -0
data/spec/content_for/different_key.erubis +1 -0
data/spec/content_for/different_key.haml +2 -0
data/spec/content_for/different_key.slim +2 -0
data/spec/content_for/layout.erb +1 -0
data/spec/content_for/layout.erubis +1 -0
data/spec/content_for/layout.haml +1 -0
data/spec/content_for/layout.slim +1 -0
data/spec/content_for/multiple_blocks.erb +4 -0
data/spec/content_for/multiple_blocks.erubis +4 -0
data/spec/content_for/multiple_blocks.haml +8 -0
data/spec/content_for/multiple_blocks.slim +8 -0
data/spec/content_for/multiple_yields.erb +3 -0
data/spec/content_for/multiple_yields.erubis +3 -0
data/spec/content_for/multiple_yields.haml +3 -0
data/spec/content_for/multiple_yields.slim +3 -0
data/spec/content_for/passes_values.erb +1 -0
data/spec/content_for/passes_values.erubis +1 -0
data/spec/content_for/passes_values.haml +1 -0
data/spec/content_for/passes_values.slim +1 -0
data/spec/content_for/same_key.erb +1 -0
data/spec/content_for/same_key.erubis +1 -0
data/spec/content_for/same_key.haml +2 -0
data/spec/content_for/same_key.slim +2 -0
data/spec/content_for/takes_values.erb +1 -0
data/spec/content_for/takes_values.erubis +1 -0
data/spec/content_for/takes_values.haml +3 -0
data/spec/content_for/takes_values.slim +3 -0
data/spec/content_for_spec.rb +201 -0
data/spec/cookies_spec.rb +782 -0
data/spec/decompile_spec.rb +44 -0
data/spec/extension_spec.rb +33 -0
data/spec/json_spec.rb +115 -0
data/spec/link_header_spec.rb +100 -0
data/spec/multi_route_spec.rb +45 -0
data/spec/namespace/foo.erb +1 -0
data/spec/namespace/nested/foo.erb +1 -0
data/spec/namespace_spec.rb +623 -0
data/spec/okjson.rb +581 -0
data/spec/reloader/app.rb.erb +40 -0
data/spec/reloader_spec.rb +441 -0
data/spec/respond_with/bar.erb +1 -0
data/spec/respond_with/bar.json.erb +1 -0
data/spec/respond_with/foo.html.erb +1 -0
data/spec/respond_with/not_html.sass +2 -0
data/spec/respond_with_spec.rb +289 -0
data/spec/spec_helper.rb +6 -0
data/spec/streaming_spec.rb +436 -0
metadata +256 -0

data/lib/sinatra/content_for.rb ADDED Viewed

@@ -0,0 +1,111 @@
+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
+  #       register 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
+    # 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/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/sinatra/contrib/all.rb ADDED Viewed

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

data/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 |meth, list|
+          list = list.map { |name| Sinatra.const_get name }
+          base.send(meth, *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/sinatra/contrib/version.rb ADDED Viewed

@@ -0,0 +1,45 @@
+module Sinatra
+  module Contrib
+    def self.version
+      VERSION
+    end
+    module VERSION
+      extend Comparable
+      MAJOR     = 1
+      MINOR     = 3
+      TINY      = 0
+      SIGNATURE = [MAJOR, MINOR, TINY]
+      STRING    = SIGNATURE.join '.'
+      def self.major; MAJOR  end
+      def self.minor; MINOR  end
+      def self.tiny;  TINY   end
+      def self.to_s;  STRING end
+      def self.hash
+        STRING.hash
+      end
+      def self.<=>(other)
+        other = other.split('.').map { |i| i.to_i } if other.respond_to? :split
+        SIGNATURE <=> Array(other)
+      end
+      def self.inspect
+        STRING.inspect
+      end
+      def self.respond_to?(meth, *)
+        return true if super
+        meth.to_s !~ /^__|^to_str$/ and STRING.respond_to? meth
+      end
+      def self.method_missing(meth, *args, &block)
+        return super unless STRING.respond_to?(meth)
+        STRING.send(meth, *args, &block)
+      end
+    end
+  end
+end

data/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: #{cookie[: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 you will use them:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/link_header"
+  #
+  #     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)
+        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.include? "expires=Thu, 01-Jan-1970 00:00:00 GMT"
+            @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