rubycut-sinatra-contrib 1.4.0

data/lib/sinatra/multi_route.rb

@@ -0,0 +1,87 @@
+require 'sinatra/base'
+
+module Sinatra
+  # = Sinatra::MultiRoute
+  #
+  # Create multiple routes with one statement.
+  #
+  # == Usage
+  #
+  # Use this extension to create a handler for multiple routes:
+  #
+  #   get '/foo', '/bar' do
+  #     # ...
+  #   end
+  #
+  # Or for multiple verbs:
+  #
+  #   route :get, :post, '/' do
+  #     # ...
+  #   end
+  #
+  # Or for multiple verbs and multiple routes:
+  #
+  #   route :get, :post, ['/foo', '/bar'] do
+  #     # ...
+  #   end
+  #
+  # Or even for custom verbs:
+  #
+  #   route 'LIST', '/' do
+  #     # ...
+  #   end
+  #
+  # === Classic Application
+  #
+  # To use the extension in a classic application all you need to do is require
+  # it:
+  #
+  #     require "sinatra"
+  #     require "sinatra/multi_route"
+  #
+  #     # Your classic application code goes here...
+  #
+  # === 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/multi_route"
+  #
+  #     class MyApp < Sinatra::Base
+  #       register Sinatra::MultiRoute
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  module MultiRoute
+    def head(*args, &block)     super(*route_args(args), &block)  end
+    def delete(*args, &block)   super(*route_args(args), &block)  end
+    def get(*args, &block)      super(*route_args(args), &block)  end
+    def options(*args, &block)  super(*route_args(args), &block)  end
+    def patch(*args, &block)    super(*route_args(args), &block)  end
+    def post(*args, &block)     super(*route_args(args), &block)  end
+    def put(*args, &block)      super(*route_args(args), &block)  end
+
+    def route(*args, &block)
+      options = Hash === args.last ? args.pop : {}
+      routes = [*args.pop]
+      args.each do |verb|
+        verb = verb.to_s.upcase if Symbol === verb
+        routes.each do |route|
+          super(verb, route, options, &block)
+        end
+      end
+    end
+
+    private
+
+    def route_args(args)
+      options = Hash === args.last ? args.pop : {}
+      [args, options]
+    end
+  end
+
+  register MultiRoute
+end

data/lib/sinatra/namespace.rb

@@ -0,0 +1,284 @@
+require 'backports'
+require 'sinatra/base'
+require 'sinatra/decompile'
+
+module Sinatra
+
+  # = Sinatra::Namespace
+  #
+  # <tt>Sinatra::Namespace</tt> is an extension that adds namespaces to an
+  # application.  This namespaces will allow you to share a path prefix for the
+  # routes within the namespace, and define filters, conditions and error
+  # handlers exclusively for them.  Besides that, you can also register helpers
+  # and extensions that will be used only within the namespace.
+  #
+  # == Usage
+  #
+  # 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:
+  #
+  #     namespace '/blog' do
+  #       get { haml :blog }
+  #       get '/:entry_permalink' do
+  #         @entry = Entry.find_by_permalink!(params[:entry_permalink])
+  #         haml :entry
+  #       end
+  #
+  #       # More blog routes...
+  #     end
+  #
+  # by a condition:
+  #
+  #     namespace :host_name => 'localhost' do
+  #       get('/admin/dashboard') { haml :dashboard }
+  #       get('/admin/login')     { haml :login }
+  #
+  #       # More admin routes...
+  #     end
+  #
+  # or both:
+  #
+  #     namespace '/admin', :host_name => 'localhost' do
+  #       get('/dashboard')  { haml :dashboard }
+  #       get('/login')      { haml :login }
+  #       post('/login')     { login_user }
+  #
+  #       # More admin routes...
+  #     end
+  #
+  # When you define a filter or an error handler, or register an extension or a
+  # set of helpers within a namespace, they only affect the routes defined in
+  # it.  For instance, lets define a before filter to prevent the access of
+  # unauthorized users to the admin section of the application:
+  #
+  #     namespace '/admin' do
+  #       helpers AdminHelpers
+  #       before  { authenticate unless request.path_info == '/admin/login' }
+  #
+  #       get '/dashboard' do
+  #         # Only authenticated users can access here...
+  #         haml :dashboard
+  #       end
+  #
+  #       # More admin routes...
+  #     end
+  #
+  #     get '/' do
+  #       # Any user can access here...
+  #       haml :index
+  #     end
+  #
+  # Well, they actually also affect the nested namespaces:
+  #
+  #     namespace '/admin' do
+  #       helpers AdminHelpers
+  #       before  { authenticate unless request.path_info == '/admin/login' }
+  #
+  #       namespace '/users' do
+  #         get do
+  #           # Only authenticated users can access here...
+  #           @users = User.all
+  #           haml :users
+  #         end
+  #
+  #         # More user admin routes...
+  #       end
+  #
+  #       # More admin routes...
+  #     end
+  #
+  # === Classic Application Setup
+  #
+  # To be able to use namespaces in a classic application all you need to do is
+  # require the extension:
+  #
+  #     require "sinatra"
+  #     require "sinatra/namespace"
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application Setup
+  #
+  # To be able to use namespaces in a modular application all you need to do is
+  # require the extension, and then, register it:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/namespace"
+  #
+  #     class MyApp < Sinatra::Base
+  #       register Sinatra::Namespace
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  module Namespace
+    def self.new(base, pattern, conditions = {}, &block)
+      Module.new do
+        extend NamespacedMethods
+        include InstanceMethods
+        @base, @extensions, @errors = base, [], {}
+        @pattern, @conditions = compile(pattern, conditions)
+        @templates            = Hash.new { |h,k| @base.templates[k] }
+        namespace = self
+        before { extend(@namespace = namespace) }
+        class_eval(&block)
+      end
+    end
+
+    module InstanceMethods
+      def settings
+        @namespace
+      end
+
+      def template_cache
+        super.fetch(:nested, @namespace) { Tilt::Cache.new }
+      end
+    end
+
+    module SharedMethods
+      def namespace(pattern, conditions = {}, &block)
+        Sinatra::Namespace.new(self, pattern, conditions, &block)
+      end
+    end
+
+    module NamespacedMethods
+      include SharedMethods
+      include Sinatra::Decompile
+      attr_reader :base, :templates
+
+      def self.prefixed(*names)
+        names.each { |n| define_method(n) { |*a, &b| prefixed(n, *a, &b) }}
+      end
+
+      prefixed :before, :after, :delete, :get, :head, :options, :patch, :post, :put
+
+      def helpers(*extensions, &block)
+        class_eval(&block) if block_given?
+        include(*extensions) if extensions.any?
+      end
+
+      def register(*extensions, &block)
+        extensions << Module.new(&block) if block_given?
+        @extensions += extensions
+        extensions.each do |extension|
+          extend extension
+          extension.registered(self) if extension.respond_to?(:registered)
+        end
+      end
+
+      def invoke_hook(name, *args)
+        @extensions.each { |e| e.send(name, *args) if e.respond_to?(name) }
+      end
+
+      def not_found(&block)
+        error(404, &block)
+      end
+
+      def 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 do |c|
+          errors = @errors[c] ||= []
+          errors << args
+        end
+      end
+
+      def respond_to(*args)
+        return @conditions[:provides] || base.respond_to if args.empty?
+        @conditions[:provides] = args
+      end
+
+      def set(key, value = self, &block)
+        raise ArgumentError, "may not set #{key}" if key != :views
+        return key.each { |k,v| set(k, v) } if block.nil? and value == self
+        block ||= proc { value }
+        singleton_class.send(:define_method, key, &block)
+      end
+
+      def enable(*opts)
+        opts.each { |key| set(key, true) }
+      end
+
+      def disable(*opts)
+        opts.each { |key| set(key, false) }
+      end
+
+      def template(name, &block)
+        filename, line = caller_locations.first
+        templates[name] = [block, filename, line.to_i]
+      end
+
+      def layout(name=:layout, &block)
+        template name, &block
+      end
+
+      private
+
+      def app
+        base.respond_to?(:base) ? base.base : base
+      end
+
+      def compile(pattern, conditions, default_pattern = nil)
+        if pattern.respond_to? :to_hash
+          conditions = conditions.merge pattern.to_hash
+          pattern = nil
+        end
+        base_pattern, base_conditions = @pattern, @conditions
+        pattern         ||= default_pattern
+        base_pattern    ||= base.pattern    if base.respond_to? :pattern
+        base_conditions ||= base.conditions if base.respond_to? :conditions
+        [ prefixed_path(base_pattern, pattern),
+          (base_conditions || {}).merge(conditions) ]
+      end
+
+      def prefixed_path(a, b)
+        return a || b || // unless a and b
+        a, b = decompile(a), decompile(b) unless a.class == b.class
+        a, b = regexpify(a), regexpify(b) unless a.class == b.class
+        path = a.class.new "#{a}#{b}"
+        path = /^#{path}$/ if path.is_a? Regexp and base == app
+        path
+      end
+
+      def regexpify(pattern)
+        pattern = Sinatra::Base.send(:compile, pattern).first.inspect
+        pattern.gsub! /^\/(\^|\\A)?|(\$|\\Z)?\/$/, ''
+        Regexp.new pattern
+      end
+
+      def prefixed(method, pattern = nil, conditions = {}, &block)
+        default = '*' if method == :before or method == :after
+        pattern, conditions = compile pattern, conditions, default
+        result = base.send(method, pattern, conditions, &block)
+        invoke_hook :route_added, method.to_s.upcase, pattern, block
+        result
+      end
+
+      def method_missing(method, *args, &block)
+        base.send(method, *args, &block)
+      end
+    end
+
+    module BaseMethods
+      include SharedMethods
+    end
+
+    def self.extend_object(base)
+      base.extend BaseMethods
+    end
+  end
+
+  register Sinatra::Namespace
+  Delegator.delegate :namespace
+end

data/lib/sinatra/reloader.rb

@@ -0,0 +1,394 @@
+require 'sinatra/base'
+
+module Sinatra
+
+  # = Sinatra::Reloader
+  #
+  # Extension to reload modified files.  Useful during development,
+  # since it will automatically require files defining routes, filters,
+  # error handlers and inline templates, with every incoming request,
+  # but only if they have been updated.
+  #
+  # == Usage
+  #
+  # === Classic Application
+  #
+  # To enable the reloader in a classic application all you need to do is
+  # require it:
+  #
+  #     require "sinatra"
+  #     require "sinatra/reloader" if development?
+  #
+  #     # Your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # To enable the reloader in a modular application all you need to do is
+  # require it, and then, register it:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/reloader"
+  #
+  #     class MyApp < Sinatra::Base
+  #       configure :development do
+  #         register Sinatra::Reloader
+  #       end
+  #
+  #       # Your modular application code goes here...
+  #     end
+  #
+  # == Changing the Reloading Policy
+  #
+  # You can refine the reloading policy with +also_reload+ and
+  # +dont_reload+, to customize which files should, and should not, be
+  # reloaded, respectively.
+  #
+  # === Classic Application
+  #
+  # Simply call the methods:
+  #
+  #     require "sinatra"
+  #     require "sinatra/reloader" if development?
+  #
+  #     also_reload '/path/to/some/file'
+  #     dont_reload '/path/to/other/file'
+  #
+  #     # Your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # Call the methods inside the +configure+ block:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/reloader"
+  #
+  #     class MyApp < Sinatra::Base
+  #       configure :development do
+  #         register Sinatra::Reloader
+  #         also_reload '/path/to/some/file'
+  #         dont_reload '/path/to/other/file'
+  #       end
+  #
+  #       # Your modular application code goes here...
+  #     end
+  #
+  module Reloader
+
+    # Watches a file so it can tell when it has been updated, and what
+    # elements does it contain.
+    class Watcher
+
+      # Represents an element of a Sinatra application that may need to
+      # be reloaded.  An element could be:
+      # * a route
+      # * a filter
+      # * an error handler
+      # * a middleware
+      # * inline templates
+      #
+      # Its +representation+ attribute is there to allow to identify the
+      # element within an application, that is, to match it with its
+      # Sinatra's internal representation.
+      class Element < Struct.new(:type, :representation)
+      end
+
+      # Collection of file +Watcher+ that can be associated with a
+      # Sinatra application.  That way, we can know which files belong
+      # to a given application and which files have been modified.  It
+      # also provides a mechanism to inform a Watcher of the elements
+      # defined in the file being watched and if its changes should be
+      # ignored.
+      class List
+        @app_list_map = Hash.new { |hash, key| hash[key] = new }
+
+        # Returns the +List+ for the application +app+.
+        def self.for(app)
+          @app_list_map[app]
+        end
+
+        # Creates a new +List+ instance.
+        def initialize
+          @path_watcher_map = Hash.new do |hash, key|
+            hash[key] = Watcher.new(key)
+          end
+        end
+
+        # Lets the +Watcher+ for the file located at +path+ know that the
+        # +element+ is defined there, and adds the +Watcher+ to the +List+,
+        # if it isn't already there.
+        def watch(path, element)
+          watcher_for(path).elements << element
+        end
+
+        # Tells the +Watcher+ for the file located at +path+ to ignore
+        # the file changes, and adds the +Watcher+ to the +List+, if
+        # it isn't already there.
+        def ignore(path)
+          watcher_for(path).ignore
+        end
+
+        # Adds a +Watcher+ for the file located at +path+ to the
+        # +List+, if it isn't already there.
+        def watcher_for(path)
+          @path_watcher_map[File.expand_path(path)]
+        end
+        alias watch_file watcher_for
+
+        # Returns an array with all the watchers in the +List+.
+        def watchers
+          @path_watcher_map.values
+        end
+
+        # Returns an array with all the watchers in the +List+ that
+        # have been updated.
+        def updated
+          watchers.find_all(&:updated?)
+        end
+      end
+
+      attr_reader :path, :elements, :mtime
+
+      # Creates a new +Watcher+ instance for the file located at +path+.
+      def initialize(path)
+        @path, @elements = path, []
+        update
+      end
+
+      # Indicates whether or not the file being watched has been modified.
+      def updated?
+        !ignore? && !removed? && mtime != File.mtime(path)
+      end
+
+      # Updates the mtime of the file being watched.
+      def update
+        @mtime = File.mtime(path)
+      end
+
+      # Indicates whether or not the file being watched has inline
+      # templates.
+      def inline_templates?
+        elements.any? { |element| element.type == :inline_templates }
+      end
+
+      # Informs that the modifications to the file being watched
+      # should be ignored.
+      def ignore
+        @ignore = true
+      end
+
+      # Indicates whether or not the modifications to the file being
+      # watched should be ignored.
+      def ignore?
+        !!@ignore
+      end
+
+      # Indicates whether or not the file being watched has been removed.
+      def removed?
+        !File.exist?(path)
+      end
+    end
+
+    # When the extension is registed it extends the Sinatra application
+    # +klass+ with the modules +BaseMethods+ and +ExtensionMethods+ and
+    # defines a before filter to +perform+ the reload of the modified files.
+    def self.registered(klass)
+      @reloader_loaded_in ||= {}
+      return if @reloader_loaded_in[klass]
+
+      @reloader_loaded_in[klass] = true
+
+      klass.extend BaseMethods
+      klass.extend ExtensionMethods
+      klass.set(:reloader) { klass.development? }
+      klass.set(:reload_templates) { klass.reloader? }
+      klass.before do
+        if klass.reloader?
+          if Reloader.thread_safe?
+            Thread.exclusive { Reloader.perform(klass) }
+          else
+            Reloader.perform(klass)
+          end
+        end
+      end
+      klass.set(:inline_templates, klass.app_file) if klass == Sinatra::Application
+    end
+
+    # Reloads the modified files, adding, updating and removing the
+    # needed elements.
+    def self.perform(klass)
+      Watcher::List.for(klass).updated.each do |watcher|
+        klass.set(:inline_templates, watcher.path) if watcher.inline_templates?
+        watcher.elements.each { |element| klass.deactivate(element) }
+        $LOADED_FEATURES.delete(watcher.path)
+        require watcher.path
+        watcher.update
+      end
+    end
+
+    # Indicates whether or not we can and need to run thread-safely.
+    def self.thread_safe?
+      Thread and Thread.list.size > 1 and Thread.respond_to?(:exclusive)
+    end
+
+    # Contains the methods defined in Sinatra::Base that are overriden.
+    module BaseMethods
+      # Protects Sinatra::Base.run! from being called more than once.
+      def run!(*args)
+        if settings.reloader?
+          super unless running?
+        else
+          super
+        end
+      end
+
+      # Does everything Sinatra::Base#route does, but it also tells the
+      # +Watcher::List+ for the Sinatra application to watch the defined
+      # route.
+      #
+      # Note: We are using #compile! so we don't interfere with extensions
+      # changing #route.
+      def compile!(verb, path, block, options = {})
+        source_location = block.respond_to?(:source_location) ?
+          block.source_location.first : caller_files[1]
+        signature = super
+        watch_element(
+          source_location, :route, { :verb => verb, :signature => signature }
+        )
+        signature
+      end
+
+      # Does everything Sinatra::Base#inline_templates= does, but it also
+      # tells the +Watcher::List+ for the Sinatra application to watch the
+      # inline templates in +file+ or the file who made the call to this
+      # method.
+      def inline_templates=(file=nil)
+        file = (file.nil? || file == true) ?
+          (caller_files[1] || File.expand_path($0)) : file
+        watch_element(file, :inline_templates)
+        super
+      end
+
+      # Does everything Sinatra::Base#use does, but it also tells the
+      # +Watcher::List+ for the Sinatra application to watch the middleware
+      # being used.
+      def use(middleware, *args, &block)
+        path = caller_files[1] || File.expand_path($0)
+        watch_element(path, :middleware, [middleware, args, block])
+        super
+      end
+
+      # Does everything Sinatra::Base#add_filter does, but it also tells
+      # the +Watcher::List+ for the Sinatra application to watch the defined
+      # filter.
+      def add_filter(type, path = nil, options = {}, &block)
+        source_location = block.respond_to?(:source_location) ?
+          block.source_location.first : caller_files[1]
+        result = super
+        watch_element(source_location, :"#{type}_filter", filters[type].last)
+        result
+      end
+
+      # Does everything Sinatra::Base#error does, but it also tells the
+      # +Watcher::List+ for the Sinatra application to watch the defined
+      # error handler.
+      def error(*codes, &block)
+        path = caller_files[1] || File.expand_path($0)
+        result = super
+        codes.each do |c|
+          watch_element(path, :error, :code => c, :handler => @errors[c])
+        end
+        result
+      end
+
+      # Does everything Sinatra::Base#register does, but it also lets the
+      # reloader know that an extension is being registered, because the
+      # elements defined in its +registered+ method need a special treatment.
+      def register(*extensions, &block)
+        start_registering_extension
+        result = super
+        stop_registering_extension
+        result
+      end
+
+      # Does everything Sinatra::Base#register does and then registers the
+      # reloader in the +subclass+.
+      def inherited(subclass)
+        result = super
+        subclass.register Sinatra::Reloader
+        result
+      end
+    end
+
+    # Contains the methods that the extension adds to the Sinatra application.
+    module ExtensionMethods
+      # Removes the +element+ from the Sinatra application.
+      def deactivate(element)
+        case element.type
+        when :route then
+          verb      = element.representation[:verb]
+          signature = element.representation[:signature]
+          (routes[verb] ||= []).delete(signature)
+        when :middleware then
+          @middleware.delete(element.representation)
+        when :before_filter then
+          filters[:before].delete(element.representation)
+        when :after_filter then
+          filters[:after].delete(element.representation)
+        when :error then
+          code    = element.representation[:code]
+          handler = element.representation[:handler]
+          @errors.delete(code) if @errors[code] == handler
+        end
+      end
+
+      # Indicates with a +glob+ which files should be reloaded if they
+      # have been modified.  It can be called several times.
+      def also_reload(*glob)
+        Dir[*glob].each { |path| Watcher::List.for(self).watch_file(path) }
+      end
+
+      # Indicates with a +glob+ which files should not be reloaded even if
+      # they have been modified.  It can be called several times.
+      def dont_reload(*glob)
+        Dir[*glob].each { |path| Watcher::List.for(self).ignore(path) }
+      end
+
+    private
+
+      attr_reader :register_path
+
+      # Indicates an extesion is being registered.
+      def start_registering_extension
+        @register_path = caller_files[2]
+      end
+
+      # Indicates the extesion has already been registered.
+      def stop_registering_extension
+        @register_path = nil
+      end
+
+      # Indicates whether or not an extension is being registered.
+      def registering_extension?
+        !register_path.nil?
+      end
+
+      # Builds a Watcher::Element from +type+ and +representation+ and
+      # tells the Watcher::List for the current application to watch it
+      # in the file located at +path+.
+      #
+      # If an extension is being registered, it also tells the list to
+      # watch it in the file where the extesion has been registered.
+      # This prevents the duplication of the elements added by the
+      # extension in its +registered+ method with every reload.
+      def watch_element(path, type, representation=nil)
+        list = Watcher::List.for(self)
+        element = Watcher::Element.new(type, representation)
+        list.watch(path, element)
+        list.watch(register_path, element) if registering_extension?
+      end
+    end
+  end
+
+  register Reloader
+  Delegator.delegate :also_reload, :dont_reload
+end