pirj-sinatra-contrib 1.3.0

data/lib/sinatra/reloader.rb

@@ -0,0 +1,384 @@
+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 realoader 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 realoader 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 contains.
+    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 the elements
+      # defined in the file being watched and if it 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 localted 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 file being watched mtime.
+      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
+    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
+      # 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

data/lib/sinatra/respond_with.rb

@@ -0,0 +1,245 @@
+require 'sinatra/base'
+require 'sinatra/json'
+
+module Sinatra
+  ##
+  # = Sinatra::RespondWith
+  #
+  # This extensions lets Sinatra automatically choose what template to render or
+  # action to perform depending on the request's Accept header.
+  #
+  # Example:
+  #
+  #   # Without Sinatra::RespondWith
+  #   get '/' do
+  #     data = { :name => 'example' }
+  #     request.accept.each do |type|
+  #       case type
+  #       when 'text/html'
+  #         halt haml(:index, :locals => data)
+  #       when 'text/json'
+  #         halt data.to_json
+  #       when 'application/atom+xml'
+  #         halt nokogiri(:'index.atom', :locals => data)
+  #       when 'application/xml', 'text/xml'
+  #         halt nokogiri(:'index.xml', :locals => data)
+  #       when 'text/plain'
+  #         halt 'just an example'
+  #       end
+  #     end
+  #     error 406
+  #   end
+  #
+  #   # With Sinatra::RespondWith
+  #   get '/' do
+  #     respond_with :index, :name => 'example' do |f|
+  #       f.txt { 'just an example' }
+  #     end
+  #   end
+  #
+  # Both helper methods +respond_to+ and +respond_with+ let you define custom
+  # handlers like the one above for +text/plain+. +respond_with+ additionally
+  # takes a template name and/or an object to offer the following default
+  # behavior:
+  #
+  # * If a template name is given, search for a template called
+  #   +name.format.engine+ (+index.xml.nokogiri+ in the above example).
+  # * If a template name is given, search for a templated called +name.engine+
+  #   for engines known to result in the requested format (+index.haml+).
+  # * If a file extension associated with the mime type is known to Sinatra, and
+  #   the object responds to +to_extension+, call that method and use the result
+  #   (+data.to_json+).
+  #
+  # == Security
+  #
+  # Since methods are triggered based on client input, this can lead to security
+  # issues (but not as seviere as those might apear in the first place: keep in
+  # mind that only known file extensions are used). You therefore should limit
+  # the possible formats you serve.
+  #
+  # This is possible with the +provides+ condition:
+  #
+  #   get '/', :provides => [:html, :json, :xml, :atom] do
+  #     respond_with :index, :name => 'example'
+  #   end
+  #
+  # However, since you have to set +provides+ for every route, this extension
+  # adds a app global (class method) `respond_to`, that let's you define content
+  # types for all routes:
+  #
+  #   respond_to :html, :json, :xml, :atom
+  #   get('/a') { respond_with :index, :name => 'a' }
+  #   get('/b') { respond_with :index, :name => 'b' }
+  #
+  # == Custom Types
+  #
+  # Use the +on+ method for defining actions for custom types:
+  #
+  #   get '/' do
+  #     respond_to do |f|
+  #       f.xml { nokogiri :index }
+  #       f.on('application/custom') { custom_action }
+  #       f.on('text/*') { data.to_s }
+  #       f.on('*/*') { "matches everything" }
+  #     end
+  #   end
+  #
+  # Definition order does not matter.
+  module RespondWith
+    class Format
+      def initialize(app)
+        @app, @map, @generic, @default = app, {}, {}, nil
+      end
+
+      def on(type, &block)
+        @app.settings.mime_types(type).each do |mime|
+          case mime
+          when '*/*'            then @default     = block
+          when /^([^\/]+)\/\*$/ then @generic[$1] = block
+          else                       @map[mime]   = block
+          end
+        end
+      end
+
+      def finish
+        yield self if block_given?
+        mime_type = @app.content_type             ||
+          @app.request.preferred_type(@map.keys)  ||
+          @app.request.preferred_type             ||
+          'text/html'
+        type = mime_type.split(/\s*;\s*/, 2).first
+        handlers = [@map[type], @generic[type[/^[^\/]+/]], @default].compact
+        handlers.each do |block|
+          if result = block.call(type)
+            @app.content_type mime_type
+            @app.halt result
+          end
+        end
+        @app.halt 406
+      end
+
+      def method_missing(meth, *args, &block)
+        return super if args.any? or block.nil? or not @app.mime_type(meth)
+        on(meth, &block)
+      end
+    end
+
+    module Helpers
+      include Sinatra::JSON
+
+      def respond_with(template, object = nil, &block)
+        object, template = template, nil unless Symbol === template
+        format = Format.new(self)
+        format.on "*/*" do |type|
+          exts = settings.ext_map[type]
+          exts << :xml if type.end_with? '+xml'
+          if template
+            args = template_cache.fetch(type, template) { template_for(template, exts) }
+            if args.any?
+              locals = { :object => object }
+              locals.merge! object.to_hash if object.respond_to? :to_hash
+              args << { :locals => locals }
+              halt send(*args)
+            end
+          end
+          if object
+            exts.each do |ext|
+              halt json(object) if ext == :json
+              next unless meth = "to_#{ext}" and object.respond_to? meth
+              halt(*object.send(meth))
+            end
+          end
+          false
+        end
+        format.finish(&block)
+      end
+
+      def respond_to(&block)
+        Format.new(self).finish(&block)
+      end
+
+      private
+
+      def template_for(name, exts)
+        # in production this is cached, so don't worry to much about runtime
+        possible = []
+        settings.template_engines[:all].each do |engine|
+          exts.each { |ext| possible << [engine, "#{name}.#{ext}"] }
+        end
+        exts.each do |ext|
+          settings.template_engines[ext].each { |e| possible << [e, name] }
+        end
+        possible.each do |engine, template|
+          # not exactly like Tilt[engine], but does not trigger a require
+          klass = Tilt.mappings[Tilt.normalize(engine)].first
+          find_template(settings.views, template, klass) do |file|
+            next unless File.exist? file
+            return settings.rendering_method(engine) << template.to_sym
+          end
+        end
+        [] # nil or false would not be cached
+      end
+    end
+
+    attr_accessor :ext_map
+
+    def remap_extensions
+      ext_map.clear
+      Rack::Mime::MIME_TYPES.each { |e,t| ext_map[t] << e[1..-1].to_sym }
+      ext_map['text/javascript'] << 'js'
+      ext_map['text/xml'] << 'xml'
+    end
+
+    def mime_type(*)
+      result = super
+      remap_extensions
+      result
+    end
+
+    def respond_to(*formats)
+      if formats.any?
+        @respond_to ||= []
+        @respond_to.concat formats
+      elsif @respond_to.nil? and superclass.respond_to? :respond_to
+        superclass.respond_to
+      else
+        @respond_to
+      end
+    end
+
+    def rendering_method(engine)
+      return [engine] if Sinatra::Templates.method_defined? engine
+      return [:mab] if engine.to_sym == :markaby
+      [:render, :engine]
+    end
+
+    private
+
+    def compile!(verb, path, block, options = {})
+      options[:provides] ||= respond_to if respond_to
+      super
+    end
+
+    ENGINES = {
+      :css  => [:less,  :sass, :scss],
+      :xml  => [:builder, :nokogiri],
+      :js   => [:coffee],
+      :html => [:erb, :erubis, :haml, :slim, :liquid, :radius, :mab, :markdown,
+        :textile, :rdoc],
+      :all  => Sinatra::Templates.instance_methods.map(&:to_sym) + [:mab] -
+        [:find_template, :markaby]
+    }
+
+    ENGINES.default = []
+
+    def self.registered(base)
+      base.ext_map = Hash.new { |h,k| h[k] = [] }
+      base.set :template_engines, ENGINES.dup
+      base.remap_extensions
+      base.helpers Helpers
+    end
+  end
+
+  register RespondWith
+  Delegator.delegate :respond_to
+end