pirj-sinatra-contrib 1.3.0

data/lib/sinatra/contrib.rb

@@ -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

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

data/lib/sinatra/contrib/setup.rb

@@ -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

@@ -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/decompile.rb

@@ -0,0 +1,113 @@
+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 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
+      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! encoded(' '), ' '
+      return pattern if str =~ /^[\.\+]/
+      str.gsub! /\([^\(\)]*\)/ do |part|
+        case part
+        when '(.*?)'
+          return pattern if keys.shift != 'splat'
+          '*'
+        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.encode(char)
+      enc = "(?:#{Regexp.escape enc}|#{URI.encode char, /./})" 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 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.
+  #
+  # Is important to be aware that this mixin remembers the methods 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