rubycut-sinatra-contrib 1.4.0

data/lib/sinatra/respond_with.rb

@@ -0,0 +1,249 @@
+require 'sinatra/json'
+require 'sinatra/base'
+
+module Sinatra
+  #
+  # = Sinatra::RespondWith
+  #
+  # These extensions let 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 severe as those might appear in the first place: keep in
+  # mind that only known file extensions are used). You 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 an app global (class method) `respond_to`, that lets 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(method, *args, &block)
+        return super if args.any? or block.nil? or not @app.mime_type(method)
+        on(method, &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
+
+              renderer = args.first
+              options = args[1..-1] + [{:locals => locals}]
+
+              halt send(renderer, *options)
+            end
+          end
+          if object
+            exts.each do |ext|
+              halt json(object) if ext == :json
+              next unless object.respond_to? method = "to_#{ext}"
+              halt(*object.send(method))
+            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 too 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],
+      :json => [:yajl],
+      :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

data/lib/sinatra/streaming.rb

@@ -0,0 +1,267 @@
+require 'sinatra/base'
+require 'eventmachine'
+require 'backports'
+
+module Sinatra
+
+  # = Sinatra::Streaming
+  #
+  # Sinatra 1.3 introduced the +stream+ helper. This addon improves the
+  # streaming API by making the stream object immitate an IO object, turning
+  # it into a real Deferrable and making the body play nicer with middleware
+  # unaware of streaming.
+  #
+  # == IO-like behavior
+  #
+  # This is useful when passing the stream object to a library expecting an
+  # IO or StringIO object.
+  #
+  #   get '/' do
+  #     stream do |out|
+  #       out.puts "Hello World!", "How are you?"
+  #       out.write "Written #{out.pos} bytes so far!\n"
+  #       out.putc(65) unless out.closed?
+  #       out.flush
+  #     end
+  #   end
+  #
+  # == Proper Deferrable
+  #
+  # Handy when using EventMachine.
+  #
+  #   list = []
+  #
+  #   get '/' do
+  #     stream(:keep_open) do |out|
+  #       list << out
+  #       out.callback { list.delete out }
+  #       out.errback do
+  #         logger.warn "lost connection"
+  #         list.delete out
+  #       end
+  #     end
+  #   end
+  #
+  # == Better Middleware Handling
+  #
+  # Blocks passed to #map! or #map will actually be applied when streaming
+  # takes place (as you might have suspected, #map! applies modifications
+  # to the current body, while #map creates a new one):
+  #
+  #   class StupidMiddleware
+  #     def initialize(app) @app = app end
+  #
+  #     def call(env)
+  #       status, headers, body = @app.call(env)
+  #       body.map! { |e| e.upcase }
+  #       [status, headers, body]
+  #     end
+  #   end
+  #
+  #   use StupidMiddleware
+  #
+  #   get '/' do
+  #     stream do |out|
+  #       out.puts "still"
+  #       sleep 1
+  #       out.puts "streaming"
+  #     end
+  #   end
+  #
+  # Even works if #each is used to generate an Enumerator:
+  #
+  #   def call(env)
+  #     status, headers, body = @app.call(env)
+  #     body = body.each.map { |s| s.upcase }
+  #     [status, headers, body]
+  #   end
+  #
+  # Note that both examples violate the Rack specification.
+  #
+  # == Setup
+  #
+  # In a classic application:
+  #
+  #   require "sinatra"
+  #   require "sinatra/streaming"
+  #
+  # In a modular application:
+  #
+  #   require "sinatra/base"
+  #   require "sinatra/streaming"
+  #
+  #   class MyApp < Sinatra::Base
+  #     helpers Sinatra::Streaming
+  #   end
+  module Streaming
+    def stream(*)
+      stream = super
+      stream.extend Stream
+      stream.app = self
+      env['async.close'].callback { stream.close } if env.key? 'async.close'
+      stream
+    end
+
+    module Stream
+      include EventMachine::Deferrable
+
+      attr_accessor :app, :lineno, :pos, :transformer, :closed
+      alias tell pos
+      alias closed? closed
+
+      def self.extended(obj)
+        obj.closed, obj.lineno, obj.pos = false, 0, 0
+        obj.callback { obj.closed = true }
+        obj.errback  { obj.closed = true }
+      end
+
+      def <<(data)
+        raise IOError, 'not opened for writing' if closed?
+        data = data.to_s
+        data = @transformer[data] if @transformer
+        @pos += data.bytesize
+        super(data)
+      end
+
+      def each
+        # that way body.each.map { ... } works
+        return self unless block_given?
+        super
+      end
+
+      def map(&block)
+        # dup would not copy the mixin
+        clone.map!(&block)
+      end
+
+      def map!(&block)
+        if @transformer
+          inner, outer = @transformer, block
+          block = proc { |value| outer[inner[value]] }
+        end
+        @transformer = block
+        self
+      end
+
+      def write(data)
+        self << data
+        data.to_s.bytesize
+      end
+
+      alias syswrite      write
+      alias write_nonblock write
+
+      def print(*args)
+        args.each { |arg| self << arg }
+        nil
+      end
+
+      def printf(format, *args)
+        print(format.to_s % args)
+      end
+
+      def putc(c)
+        print c.chr
+      end
+
+      def puts(*args)
+        args.each { |arg| self << "#{arg}\n" }
+        nil
+      end
+
+      def close
+        @scheduler.schedule { succeed }
+        nil
+      end
+
+      def close_read
+        raise IOError, "closing non-duplex IO for reading"
+      end
+
+      def closed_read?
+        true
+      end
+
+      def closed_write?
+        closed?
+      end
+
+      def external_encoding
+        Encoding.find settings.default_encoding
+      rescue NameError
+        settings.default_encoding
+      end
+
+      def closed?
+        @closed
+      end
+
+      def settings
+        app.settings
+      end
+
+      def rewind
+        @pos = @lineno = 0
+      end
+
+      def not_open_for_reading(*)
+        raise IOError, "not opened for reading"
+      end
+
+      alias bytes         not_open_for_reading
+      alias eof?          not_open_for_reading
+      alias eof           not_open_for_reading
+      alias getbyte       not_open_for_reading
+      alias getc          not_open_for_reading
+      alias gets          not_open_for_reading
+      alias read          not_open_for_reading
+      alias read_nonblock not_open_for_reading
+      alias readbyte      not_open_for_reading
+      alias readchar      not_open_for_reading
+      alias readline      not_open_for_reading
+      alias readlines     not_open_for_reading
+      alias readpartial   not_open_for_reading
+      alias sysread       not_open_for_reading
+      alias ungetbyte     not_open_for_reading
+      alias ungetc        not_open_for_reading
+      private :not_open_for_reading
+
+      def enum_not_open_for_reading(*)
+        not_open_for_reading if block_given?
+        enum_for(:not_open_for_reading)
+      end
+
+      alias chars     enum_not_open_for_reading
+      alias each_line enum_not_open_for_reading
+      alias each_byte enum_not_open_for_reading
+      alias each_char enum_not_open_for_reading
+      alias lines     enum_not_open_for_reading
+      undef enum_not_open_for_reading
+
+      def dummy(*) end
+      alias flush             dummy
+      alias fsync             dummy
+      alias internal_encoding dummy
+      alias pid               dummy
+      undef dummy
+
+      def seek(*)
+        0
+      end
+
+      alias sysseek seek
+
+      def sync
+        true
+      end
+
+      def tty?
+        false
+      end
+
+      alias isatty tty?
+    end
+  end
+
+  helpers Streaming
+end