sinatra-contrib 1.3.2 → 1.4.0

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://secure.travis-ci.org/sinatra/sinatra-contrib.png)](http://travis-ci.org/sinatra/sinatra-contrib)
+
 Collection of common Sinatra extensions, semi-officially supported.
 
 # Goals
@@ -6,13 +8,6 @@ Collection of common Sinatra extensions, semi-officially supported.
 * High code quality, high test coverage
 * Include plugins people usually ask for a lot
 
-# TODO
-
-* Write documentation, integrate into Sinatra website
-* Finish imports and rewrites
-* Wrap up first release
-* Find contributors (both code and docs)
-
 # Included extensions
 
 ## Common Extensions
@@ -46,7 +41,7 @@ Currently included:
 
 * `sinatra/namespace`: Adds namespace support to Sinatra.
 
-* `sinatra/respond_with`: Choose action and/or template depending automatically
+* `sinatra/respond_with`: Choose action and/or template automatically
   depending on the incoming request. Adds helpers `respond_to` and
   `respond_with`.
 
@@ -70,6 +65,12 @@ Currently included:
 * `sinatra/test_helpers`: Helper methods to ease testing your Sinatra
   application. Partly extracted from Sinatra. Testing framework agnostic
 
+# Installation
+Add `gem 'sinatra-contrib'` to *Gemfile*, then execute `bundle install`.  
+
+If you don't use Bundler, install the gem manually by executing `gem install sinatra-contrib` in your command line.
+
+
 # Usage
 
 ## Classic Style

data/lib/sinatra/capture.rb

@@ -3,21 +3,103 @@ require 'sinatra/engine_tracking'
 require 'backports'
 
 module Sinatra
+  #
+  # = Sinatra::Capture
+  #
+  # Extension that enables blocks inside other extensions.
+  # It currently works for erb, slim and haml.
+  # Enables mixing of different template languages.
+  #
+  # Example:
+  #
+  #    # in hello_world.erb
+  #
+  #    Say
+  #    <% a = capture do %>World<% end %>
+  #    Hello <%= a %>!
+  #
+  #    # in hello_world.slim
+  #
+  #    | Say
+  #    - a = capture do
+  #      | World
+  #    |  Hello #{a}!
+  #
+  #    # in hello_world.haml
+  #
+  #    Say
+  #    - a = capture do
+  #      World
+  #      Hello #{a.strip}!
+  #
+  #
+  # You can also use nested blocks.
+  #
+  # Example
+  #
+  #     # in hello_world.erb
+  #
+  #     Say
+  #     <% a = capture do %>
+  #       <% b = capture do %>World<% end %>
+  #         <%= b %>!
+  #     <% end %>
+  #     Hello <%= a.strip %>
+  #
+  #
+  # The main advantage of capture is mixing of different template engines.
+  #
+  # Example
+  #
+  #    # in mix_me_up.slim
+  #
+  #    - two = capture do
+  #      - erb "<%= 1 + 1 %>"
+  #    | 1 + 1 = #{two}
+  #
+  # == Usage
+  #
+  # === Classic Application
+  #
+  # In a classic application simply require the helpers, and start using them:
+  #
+  #     require "sinatra"
+  #     require "sinatra/capture"
+  #
+  #     # 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/capture"
+  #
+  #     class MyApp < Sinatra::Base
+  #       helpers Sinatra::Capture
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
   module Capture
     include Sinatra::EngineTracking
 
     DUMMIES = {
-      :haml => "!= capture_haml(*args, &block)",
-      :erb  => "<% @capture = yield(*args) %>",
-      :slim => "== yield(*args)"
+      :haml   => "!= capture_haml(*args, &block)",
+      :erubis => "<% @capture = yield(*args) %>",
+      :slim   => "== yield(*args)"
     }
 
-    DUMMIES[:erubis] = DUMMIES[:erb]
-
     def capture(*args, &block)
       @capture = nil
       if current_engine == :ruby
         result = block[*args]
+      elsif current_engine == :erb
+        @_out_buf, _buf_was = '', @_out_buf
+        block[*args]
+        result = eval('@_out_buf', block.binding)
+        @_out_buf = _buf_was
       else
         buffer     = eval '_buf if defined?(_buf)', block.binding
         old_buffer = buffer.dup if buffer

data/lib/sinatra/config_file.rb

@@ -1,5 +1,6 @@
 require 'sinatra/base'
 require 'yaml'
+require 'erb'
 
 module Sinatra
 
@@ -10,7 +11,7 @@ module Sinatra
   # the files contains specific environment settings and it will use the
   # corresponding to the current one.
   #
-  # Within the application you can access those options through +settings+.  If
+  # You can access those options through +settings+ within the application. If
   # you try to get the value for a setting that hasn't been defined in the
   # config file for the current environment, you will get whatever it was set
   # to in the application.
@@ -94,10 +95,23 @@ module Sinatra
   #
   # Be aware that if you have a different environment, besides development,
   # test and production, you will also need to adjust the +environments+
-  # setting.  For instance, when you also have a staging environment:
+  # setting, otherwise the settings will not load.  For instance, when
+  # you also have a staging environment:
   #
   #     set :environments, %w{development test production staging}
   #
+  # If you wish to provide defaults that may be shared among all the environments,
+  # this can be done by using one of the existing environments as the default using
+  # the YAML alias, and then overwriting values in the other environments:
+  #
+  #     development: &common_settings
+  #       foo: 'foo'
+  #       bar: 'bar'
+  #
+  #     production:
+  #       <<: *common_settings
+  #       bar: 'baz' # override the default value
+  #
   module ConfigFile
 
     # When the extension is registered sets the +environments+ setting to the
@@ -114,7 +128,9 @@ module Sinatra
         paths.each do |pattern|
           Dir.glob(pattern) do |file|
             $stderr.puts "loading config file '#{file}'" if logging?
-            yaml = config_for_env(YAML.load_file(file)) || {}
+            document = IO.read(file)
+            document = ERB.new(document).result if file.split('.').include?('erb')
+            yaml = config_for_env(YAML.load(document)) || {}
             yaml.each_pair do |key, value|
               for_env = config_for_env(value)
               set key, for_env unless value and for_env.nil? and respond_to? key

data/lib/sinatra/content_for.rb

@@ -78,7 +78,7 @@ module Sinatra
     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:
     #
@@ -100,7 +100,7 @@ module Sinatra
     #       <%= yield_content :head %>
     #     </head>
     #
-    # Would render everything you declared with <tt>content_for 
+    # 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

data/lib/sinatra/contrib/setup.rb

@@ -24,9 +24,9 @@ module Sinatra
       end
 
       def registered(base)
-        @extensions.each do |meth, list|
+        @extensions.each do |method, list|
           list = list.map { |name| Sinatra.const_get name }
-          base.send(meth, *list) unless base == ::Sinatra::Application
+          base.send(method, *list) unless base == ::Sinatra::Application
         end
       end
     end

data/lib/sinatra/cookies.rb

@@ -11,7 +11,7 @@ module Sinatra
   # Allows you to read cookies:
   #
   #   get '/' do
-  #     "value: #{cookie[:something]}"
+  #     "value: #{cookies[:something]}"
   #   end
   #
   # And of course to write cookies:
@@ -42,7 +42,7 @@ module Sinatra
   # === Modular Application
   #
   # In a modular application you need to require the helpers, and then tell
-  # the application you will use them:
+  # the application to use them:
   #
   #     require "sinatra/base"
   #     require "sinatra/cookies"
@@ -111,7 +111,7 @@ module Sinatra
 
       def delete(key)
         result = self[key]
-        @response.delete_cookie(key.to_s)
+        @response.delete_cookie(key.to_s, @options)
         result
       end
 
@@ -305,7 +305,7 @@ module Sinatra
           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"
+          if line =~ /expires=Thu, 01[-\s]Jan[-\s]1970/
             @deleted << key
           else
             @deleted.delete key

data/lib/sinatra/decompile.rb

@@ -60,7 +60,7 @@ module Sinatra
     #     end
     #   end
     #
-    # Will return the internal Regexp if unable to reconstruct the pattern,
+    # 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
@@ -70,17 +70,25 @@ module Sinatra
     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! /^\/\^?|\$?\/$/, ''
+      str.gsub! /^\/(\^|\\A)?|(\$|\\z)?\/$/, ''
       str.gsub! encoded(' '), ' '
       return pattern if str =~ /^[\.\+]/
-      str.gsub! /\([^\(\)]*\)/ do |part|
+      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
@@ -102,8 +110,8 @@ module Sinatra
 
     def encoded(char)
       return super if defined? super
-      enc = URI.encode(char)
-      enc = "(?:#{Regexp.escape enc}|#{URI.encode char, /./})" if enc == char
+      enc = URI.escape(char)
+      enc = "(?:#{escaped(char, enc).join('|')})" if enc == char
       enc = "(?:#{enc}|#{encoded('+')})" if char == " "
       enc
     end

data/lib/sinatra/extension.rb

@@ -6,12 +6,12 @@ module Sinatra
   # = Sinatra::Extension
   #
   # <tt>Sinatra::Extension</tt> is a mixin that provides some syntactic sugar
-  # for your extensions.  It allows you to call directly inside your extension
-  # module almost any <tt>Sinatra::Base</tt> method.  This means you can use
-  # +get+ to define a route, +before+ to define a before filter, +set+ to
-  # define a setting, a so on.
+  # for your extensions. It allows you to call almost any
+  # <tt>Sinatra::Base</tt> method directly inside your extension
+  # module. This means you can use +get+ to define a route, +before+
+  # to define a before filter, +set+ to define a setting and so on.
   #
-  # Is important to be aware that this mixin remembers the methods calls you
+  # Is important to be aware that this mixin remembers the method calls you
   # make, and then, when your extension is registered, replays them on the
   # Sinatra application that has been extended.  In order to do that, it
   # defines a <tt>registered</tt> method, so, if your extension defines one

data/lib/sinatra/json.rb

@@ -44,8 +44,8 @@ module Sinatra
   #
   # === Encoders
   #
-  # Per default it will try to call +to_json+ on the object, but if it doesn't
-  # respond to that message, will use its own, rather simple encoder.  You can
+  # By default it will try to call +to_json+ on the object, but if it doesn't
+  # respond to that message, it will use its own rather simple encoder.  You can
   # easily change that anyways. To use +JSON+, simply require it:
   #
   #   require 'json'
@@ -90,43 +90,39 @@ module Sinatra
   module JSON
     class << self
       def encode(object)
-        enc object, Array, Hash
+        ::MultiJson.dump(object)
       end
+    end
 
-      private
+    def json(object, options = {})
+      content_type resolve_content_type(options)
+      resolve_encoder_action  object, resolve_encoder(options)
+    end
 
-      def enc(o, *a)
-        o = o.to_s if o.is_a? Symbol
-        fail "invalid: #{o.inspect}" unless a.empty? or a.include? o.class
-        case o
-        when Float  then o.nan? || o.infinite? ? 'null' : o.inspect
-        when TrueClass, FalseClass, NilClass, Numeric, String then o.inspect
-        when Array  then map(o, "[%s]") { |e| enc(e) }
-        when Hash   then map(o, "{%s}") { |k,v| enc(k, String) + ":" + enc(v) }
-        end
-      end
+    private
 
-      def map(o, wrapper, &block)
-        wrapper % o.map(&block).join(',')
-      end
+    def resolve_content_type(options = {})
+      options[:content_type] || settings.json_content_type
     end
 
-    def json(object, options = {})
-      encoder = options[:encoder] || settings.json_encoder
-      content_type options[:content_type] || settings.json_content_type
-      if encoder.respond_to? :encode then encoder.encode(object)
-      elsif encoder.respond_to? :generate then encoder.generate(object)
-      elsif encoder.is_a? Symbol then object.__send__(encoder)
-      else fail "#{encoder} does not respond to #generate nor #encode"
-      end
+    def resolve_encoder(options = {})
+      options[:json_encoder] || settings.json_encoder
     end
-  end
+
+    def resolve_encoder_action(object, encoder)
+      [:encode, :generate].each do |method|
+        return encoder.send(method, object) if encoder.respond_to? method
+      end
+      if encoder.is_a? Symbol
+        object.__send__(encoder)
+      else 
+        fail "#{encoder} does not respond to #generate nor #encode"
+      end #if
+    end #resolve_encoder_action  
+  end #JSON
 
   Base.set :json_encoder do
-    return Yajl::Encoder if defined? Yajl::Encoder
-    return JSON if defined? JSON
-    return :to_json if {}.respond_to? :to_json and [].respond_to? :to_json
-    Sinatra::JSON
+    ::MultiJson
   end
 
   Base.set :json_content_type, :json

data/lib/sinatra/link_header.rb

@@ -53,8 +53,8 @@ module Sinatra
   #
   module LinkHeader
     ##
-    # Set Link HTTP header and returns HTML tags for telling the browser to
-    # prefetch given resources (only supported by Opera and Firefox at the 
+    # Sets Link HTTP header and returns HTML tags for telling the browser to
+    # prefetch given resources (only supported by Opera and Firefox at the
     # moment).
     def prefetch(*urls)
       link(:prefetch, *urls)

data/lib/sinatra/multi_route.rb

@@ -19,6 +19,12 @@ module Sinatra
   #     # ...
   #   end
   #
+  # Or for multiple verbs and multiple routes:
+  #
+  #   route :get, :post, ['/foo', '/bar'] do
+  #     # ...
+  #   end
+  #
   # Or even for custom verbs:
   #
   #   route 'LIST', '/' do

data/lib/sinatra/namespace.rb

@@ -14,7 +14,7 @@ module Sinatra
   #
   # == Usage
   #
-  # Once you have loaded the extension (see below), you use the +namespace+
+  # Once you have loaded the extension (see below), you can use the +namespace+
   # method to define namespaces in your application.
   #
   # You can define a namespace by a path prefix:
@@ -177,18 +177,21 @@ module Sinatra
       end
 
       def errors
-        base.errors.merge(@errors)
+        base.errors.merge(namespace_errors)
       end
 
       def namespace_errors
         @errors
       end
-      
+
       def error(*codes, &block)
         args  = Sinatra::Base.send(:compile!, "ERROR", /^#{@pattern}/, block)
         codes = codes.map { |c| Array(c) }.flatten
         codes << Exception if codes.empty?
-        codes.each { |c| @errors[c] = args }
+        codes.each do |c|
+          errors = @errors[c] ||= []
+          errors << args
+        end
       end
 
       def respond_to(*args)
@@ -262,8 +265,8 @@ module Sinatra
         result
       end
 
-      def method_missing(meth, *args, &block)
-        base.send(meth, *args, &block)
+      def method_missing(method, *args, &block)
+        base.send(method, *args, &block)
       end
     end