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

sinatra-contrib 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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