rubycut-sinatra-contrib 1.4.0

data/lib/sinatra/decompile.rb

@@ -0,0 +1,120 @@
+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 =~ /^[\.\+]/
+      capture = '((?:[^\.\/?#%]|(?:%[^2].|%[2][^Ee]))+)'
+      str.gsub! /\([^\(\)]*\)|\([^\(\)]*\([^\(\)]*\)[^\(\)]*\)|#{Regexp.escape(capture)}/ do |part|
+        case part
+        when '(.*?)'
+          return pattern if keys.shift != 'splat'
+          '*'
+        when /^\(\?\:(\\*.)\|%[\w\[\]]+\)$/
+          $1
+        when /^\(\?\:(%\d+)\|([^\)]+|\([^\)]+\))\)$/
+          URI.unescape($1)
+        when '([^\/?#]+)', capture
+          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

data/lib/sinatra/engine_tracking.rb

@@ -0,0 +1,96 @@
+require 'sinatra/base'
+
+module Sinatra
+  module EngineTracking
+    attr_reader :current_engine
+
+    def erb?
+      @current_engine == :erb
+    end
+
+    def erubis?
+      @current_engine == :erubis or
+      erb? && Tilt[:erb] == Tilt::ErubisTemplate
+    end
+
+    def haml?
+      @current_engine == :haml
+    end
+
+    def sass?
+      @current_engine == :sass
+    end
+
+    def scss?
+      @current_engine == :scss
+    end
+
+    def less?
+      @current_engine == :less
+    end
+
+    def builder?
+      @current_engine == :builder
+    end
+
+    def liquid?
+      @current_engine == :liquid
+    end
+
+    def markdown?
+      @current_engine == :markdown
+    end
+
+    def textile?
+      @current_engine == :textile
+    end
+
+    def rdoc?
+      @current_engine == :rdoc
+    end
+
+    def radius?
+      @current_engine == :radius
+    end
+
+    def markaby?
+      @current_engine == :markaby
+    end
+
+    def coffee?
+      @current_engine == :coffee
+    end
+
+    def nokogiri?
+      @current_engine == :nokogiri
+    end
+
+    def slim?
+      @current_engine == :slim
+    end
+
+    def creole?
+      @current_engine == :creole
+    end
+
+    def initialize(*)
+      @current_engine = :ruby
+      super
+    end
+
+    def with_engine(engine)
+      @current_engine, engine_was = engine.to_sym, @current_engine
+      yield
+    ensure
+      @current_engine = engine_was
+    end
+
+    private
+
+    def render(engine, *)
+      with_engine(engine) { super }
+    end
+  end
+
+  helpers EngineTracking
+end

data/lib/sinatra/extension.rb

@@ -0,0 +1,95 @@
+require 'sinatra/base'
+require 'backports/basic_object' unless defined? BasicObject
+
+module Sinatra
+
+  # = Sinatra::Extension
+  #
+  # <tt>Sinatra::Extension</tt> is a mixin that provides some syntactic sugar
+  # 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 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
+  # too, remember to call +super+.
+  #
+  # == Usage
+  #
+  # Just require the mixin and extend your extension with it:
+  #
+  #     require 'sinatra/extension'
+  #
+  #     module MyExtension
+  #       extend Sinatra::Extension
+  #
+  #       # set some settings for development
+  #       configure :development do
+  #         set :reload_stuff, true
+  #       end
+  #
+  #       # define a route
+  #       get '/' do
+  #         'Hello World'
+  #       end
+  #
+  #       # The rest of your extension code goes here...
+  #     end
+  #
+  # You can also create an extension with the +new+ method:
+  #
+  #     MyExtension = Sinatra::Extension.new do
+  #       # Your extension code goes here...
+  #     end
+  #
+  # This is useful when you just want to pass a block to
+  # <tt>Sinatra::Base.register</tt>.
+  module Extension
+    def self.new(&block)
+      ext = Module.new.extend(self)
+      ext.class_eval(&block)
+      ext
+    end
+
+    def settings
+      self
+    end
+
+    def configure(*args, &block)
+      record(:configure, *args) { |c| c.instance_exec(c, &block) }
+    end
+
+    def registered(base = nil, &block)
+      base ? replay(base) : record(:class_eval, &block)
+    end
+
+    private
+
+    def record(method, *args, &block)
+      recorded_methods << [method, args, block]
+    end
+
+    def replay(object)
+      recorded_methods.each { |m, a, b| object.send(m, *a, &b) }
+    end
+
+    def recorded_methods
+      @recorded_methods ||= []
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless Sinatra::Base.respond_to? method
+      record(method, *args, &block)
+      DontCall.new(method)
+    end
+
+    class DontCall < BasicObject
+      def initialize(method) @method = method end
+      def method_missing(*) fail "not supposed to use result of #@method!" end
+      def inspect; "#<#{self.class}: #{@method}>" end
+    end
+  end
+end

data/lib/sinatra/json.rb

@@ -0,0 +1,130 @@
+require 'sinatra/base'
+
+module Sinatra
+
+  # = Sinatra::JSON
+  #
+  # <tt>Sinatra::JSON</tt> adds a helper method, called +json+, for (obviously)
+  # json generation.
+  #
+  # == Usage
+  #
+  # === Classic Application
+  #
+  # In a classic application simply require the helper, and start using it:
+  #
+  #     require "sinatra"
+  #     require "sinatra/json"
+  #
+  #     # define a route that uses the helper
+  #     get '/' do
+  #       json :foo => 'bar'
+  #     end
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # In a modular application you need to require the helper, and then tell the
+  # application you will use it:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/json"
+  #
+  #     class MyApp < Sinatra::Base
+  #       helpers Sinatra::JSON
+  #
+  #       # define a route that uses the helper
+  #       get '/' do
+  #         json :foo => 'bar'
+  #       end
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  # === Encoders
+  #
+  # 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'
+  #
+  # The same goes for <tt>Yajl::Encoder</tt>:
+  #
+  #   require 'yajl'
+  #
+  # For other encoders, besides requiring them, you need to define the
+  # <tt>:json_encoder</tt> setting.  For instance, for the +Whatever+ encoder:
+  #
+  #   require 'whatever'
+  #   set :json_encoder, Whatever
+  #
+  # To force +json+ to simply call +to_json+ on the object:
+  #
+  #   set :json_encoder, :to_json
+  #
+  # Actually, it can call any method:
+  #
+  #   set :json_encoder, :my_fancy_json_method
+  #
+  # === Content-Type
+  #
+  # It will automatically set the content type to "application/json".  As
+  # usual, you can easily change that, with the <tt>:json_content_type</tt>
+  # setting:
+  #
+  #   set :json_content_type, :js
+  #
+  # === Overriding the Encoder and the Content-Type
+  #
+  # The +json+ helper will also take two options <tt>:encoder</tt> and
+  # <tt>:content_type</tt>.  The values of this options are the same as the
+  # <tt>:json_encoder</tt> and <tt>:json_content_type</tt> settings,
+  # respectively.  You can also pass those to the json method:
+  #
+  #   get '/'  do
+  #     json({:foo => 'bar'}, :encoder => :to_json, :content_type => :js)
+  #   end
+  #
+  module JSON
+    class << self
+      def encode(object)
+        ::MultiJson.dump(object)
+      end
+    end
+
+    def json(object, options = {})
+      content_type resolve_content_type(options)
+      resolve_encoder_action  object, resolve_encoder(options)
+    end
+
+    private
+
+    def resolve_content_type(options = {})
+      options[:content_type] || settings.json_content_type
+    end
+
+    def resolve_encoder(options = {})
+      options[:json_encoder] || settings.json_encoder
+    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
+    ::MultiJson
+  end
+
+  Base.set :json_content_type, :json
+  helpers JSON
+end

data/lib/sinatra/link_header.rb

@@ -0,0 +1,132 @@
+require 'sinatra/base'
+
+module Sinatra
+
+  # = Sinatra::LinkHeader
+  #
+  # <tt>Sinatra::LinkHeader</tt> adds a set of helper methods to generate link
+  # HTML tags and their corresponding Link HTTP headers.
+  #
+  # == Usage
+  #
+  # Once you had set up the helpers in your application (see below), you will
+  # be able to call the following methods from inside your route handlers,
+  # filters and templates:
+  #
+  # +prefetch+::
+  #     Sets the Link HTTP headers and returns HTML tags to prefetch the given
+  #     resources.
+  #
+  # +stylesheet+::
+  #     Sets the Link HTTP headers and returns HTML tags to use the given
+  #     stylesheets.
+  #
+  # +link+::
+  #     Sets the Link HTTP headers and returns the corresponding HTML tags
+  #     for the given resources.
+  #
+  # +link_headers+::
+  #     Returns the corresponding HTML tags for the current Link HTTP headers.
+  #
+  # === Classic Application
+  #
+  # In a classic application simply require the helpers, and start using them:
+  #
+  #     require "sinatra"
+  #     require "sinatra/link_header"
+  #
+  #     # 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::LinkHeader
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  module LinkHeader
+    ##
+    # 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)
+    end
+
+    ##
+    # Sets Link HTTP header and returns HTML tags for using stylesheets.
+    def stylesheet(*urls)
+      urls << {} unless urls.last.respond_to? :to_hash
+      urls.last[:type] ||= mime_type(:css)
+      link(:stylesheet, *urls)
+    end
+
+    ##
+    # Sets Link HTTP header and returns corresponding HTML tags.
+    #
+    # Example:
+    #
+    #   # Sets header:
+    #   #   Link: </foo>; rel="next"
+    #   # Returns String:
+    #   #   '<link href="/foo" rel="next" />'
+    #   link '/foo', :rel => :next
+    #
+    #   # Multiple URLs
+    #   link :stylesheet, '/a.css', '/b.css'
+    def link(*urls)
+      opts          = urls.last.respond_to?(:to_hash) ? urls.pop : {}
+      opts[:rel]    = urls.shift unless urls.first.respond_to? :to_str
+      options       = opts.map { |k, v| " #{k}=#{v.to_s.inspect}" }
+      html_pattern  = "<link href=\"%s\"#{options.join} />"
+      http_pattern  = ["<%s>", *options].join ";"
+      link          = (response["Link"] ||= "")
+
+      urls.map do |url|
+        link << "\n" unless link.empty?
+        link << (http_pattern % url)
+        html_pattern % url
+      end.join "\n"
+    end
+
+    ##
+    # Takes the current value of th Link header(s) and generates HTML tags
+    # from it.
+    #
+    # Example:
+    #
+    #   get '/' do
+    #     # You can of course use fancy helpers like #link, #stylesheet
+    #     # or #prefetch
+    #     response["Link"] = '</foo>; rel="next"'
+    #     haml :some_page
+    #   end
+    #
+    #   __END__
+    #
+    #   @@ layout
+    #   %head= link_headers
+    #   %body= yield
+    def link_headers
+      yield if block_given?
+      return "" unless response.include? "Link"
+      response["Link"].lines.map do |line|
+        url, *opts = line.split(';').map(&:strip)
+        "<link href=\"#{url[1..-2]}\" #{opts.join " "} />"
+      end.join "\n"
+    end
+
+    def self.registered(base)
+      puts "WARNING: #{self} is a helpers module, not an extension."
+    end
+  end
+
+  helpers LinkHeader
+end