deas 0.38.0 → 0.39.0

data/Gemfile

@@ -3,5 +3,6 @@ source "https://rubygems.org"
 gemspec
 
 gem 'rake', "~> 10.4.0"
-gem 'pry', "~> 0.9.0"
+gem 'pry',  "~> 0.9.0"
+
 gem 'rack-test'

data/deas.gemspec

@@ -18,9 +18,10 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency("ns-options", ["~> 1.1", ">= 1.1.4"])
-  gem.add_dependency("rack",       ["~> 1.5"])
-  gem.add_dependency("sinatra",    ["~> 1.4"])
+  gem.add_dependency("much-plugin", ["~> 0.1"])
+  gem.add_dependency("ns-options",  ["~> 1.1", ">= 1.1.4"])
+  gem.add_dependency("rack",        ["~> 1.5"])
+  gem.add_dependency("sinatra",     ["~> 1.4"])
 
   gem.add_development_dependency("assert", ["~> 2.15"])
   gem.add_development_dependency("assert-rack-test")

data/lib/deas/deas_runner.rb

@@ -1,3 +1,4 @@
+require 'rack/utils'
 require 'deas/runner'
 
 module Deas
@@ -5,25 +6,29 @@ module Deas
   class DeasRunner < Runner
 
     def initialize(handler_class, args = nil)
-      a = args || {}
-      runner_args = a.merge(:params => NormalizedParams.new(a[:params]).value)
-      super(handler_class, runner_args)
+      args ||= {}
+      super(
+        handler_class,
+        args.merge(:params => NormalizedParams.new(args[:params]).value)
+      )
     end
 
     def run
-      run_callbacks self.handler_class.before_callbacks
-      self.handler.init
-      response_data = self.handler.run
-      run_callbacks self.handler_class.after_callbacks
-      response_data
+      catch(:halt) do
+        self.handler.deas_run_callback 'before'
+        catch(:halt){ self.handler.deas_init; self.handler.deas_run }
+        self.handler.deas_run_callback 'after'
+      end
+
+      self.to_rack.tap do |(status, headers, body)|
+        headers['Content-Length'] ||= body.inject(0) do |length, part|
+          length + Rack::Utils.bytesize(part)
+        end.to_s
+      end
     end
 
     private
 
-    def run_callbacks(callbacks)
-      callbacks.each{|proc| self.handler.instance_eval(&proc) }
-    end
-
     class NormalizedParams < Deas::Runner::NormalizedParams
       def file_type?(value)
         value.kind_of?(::Tempfile)

data/lib/deas/handler_proxy.rb

@@ -1,5 +1,5 @@
 require 'deas/exceptions'
-require 'deas/sinatra_runner'
+require 'deas/deas_runner'
 
 module Deas
 
@@ -16,15 +16,21 @@ module Deas
     end
 
     def run(server_data, sinatra_call)
-      runner = SinatraRunner.new(self.handler_class, {
-        :sinatra_call    => sinatra_call,
-        :request         => sinatra_call.request,
-        :response        => sinatra_call.response,
-        :session         => sinatra_call.session,
-        :params          => sinatra_call.params,
+      # these are not part of Deas' intended behavior and route matching
+      # they are side-effects of using Sinatra.  remove them so they won't
+      # be relied upon in Deas apps.
+      sinatra_call.params.delete(:splat)
+      sinatra_call.params.delete('splat')
+      sinatra_call.params.delete(:captures)
+      sinatra_call.params.delete('captures')
+
+      runner = DeasRunner.new(self.handler_class, {
         :logger          => server_data.logger,
         :router          => server_data.router,
-        :template_source => server_data.template_source
+        :template_source => server_data.template_source,
+        :request         => sinatra_call.request,
+        :session         => sinatra_call.session,
+        :params          => sinatra_call.params
       })
 
       runner.request.env.tap do |env|

data/lib/deas/redirect_proxy.rb

@@ -8,7 +8,7 @@ module Deas
 
     attr_reader :handler_class_name, :handler_class
 
-    def initialize(router, path = nil, &block)
+    def initialize(router, location = nil, &block)
       @handler_class = Class.new do
         include Deas::ViewHandler
 
@@ -17,34 +17,34 @@ module Deas
           @router = value
         end
 
-        def self.redirect_path; @redirect_path; end
-        def self.redirect_path=(value)
-          @redirect_path = value
+        def self.redirect_location; @redirect_location; end
+        def self.redirect_location=(value)
+          @redirect_location = value
         end
 
         def self.name; 'Deas::RedirectHandler'; end
 
-        attr_reader :redirect_path
+        attr_reader :redirect_location
 
         def init!
-          @redirect_path = self.class.router.prepend_base_url(
-            self.instance_eval(&self.class.redirect_path)
+          @redirect_location = self.class.router.prepend_base_url(
+            self.instance_eval(&self.class.redirect_location)
           )
         end
 
         def run!
-          redirect @redirect_path
+          redirect @redirect_location
         end
 
       end
 
       @handler_class.router = router
-      @handler_class.redirect_path = if path.nil?
+      @handler_class.redirect_location = if location.nil?
         block
-      elsif path.kind_of?(Deas::Url)
-        proc{ path.path_for(params) }
+      elsif location.kind_of?(Deas::Url)
+        proc{ location.path_for(params) }
       else
-        proc{ path }
+        proc{ location }
       end
       @handler_class_name = @handler_class.name
     end

data/lib/deas/runner.rb

@@ -1,4 +1,5 @@
 require 'rack/utils'
+require 'pathname'
 require 'deas/logger'
 require 'deas/router'
 require 'deas/template_source'
@@ -7,40 +8,115 @@ module Deas
 
   class Runner
 
+    DEFAULT_MIME_TYPE = 'application/octet-stream'.freeze
+    DEFAULT_CHARSET   = 'utf-8'.freeze
+    DEFAULT_STATUS    = 200.freeze
+    DEFAULT_BODY      = [].freeze
+
     attr_reader :handler_class, :handler
-    attr_reader :request, :response, :session
-    attr_reader :params, :logger, :router, :template_source
+    attr_reader :logger, :router, :template_source
+    attr_reader :request, :session, :params
 
     def initialize(handler_class, args = nil)
+      @status, @headers, @body = nil, Rack::Utils::HeaderHash.new, nil
+
+      args ||= {}
+      @logger          = args[:logger] || Deas::NullLogger.new
+      @router          = args[:router] || Deas::Router.new
+      @template_source = args[:template_source] || Deas::NullTemplateSource.new
+      @request         = args[:request]
+      @session         = args[:session]
+      @params          = args[:params] || {}
+
       @handler_class = handler_class
       @handler = @handler_class.new(self)
+    end
+
+    def run
+      raise NotImplementedError
+    end
+
+    def to_rack
+      [self.status || DEFAULT_STATUS, self.headers.to_hash, self.body || DEFAULT_BODY]
+    end
 
-      a = args || {}
-      @request         = a[:request]
-      @response        = a[:response]
-      @session         = a[:session]
-      @params          = a[:params] || {}
-      @logger          = a[:logger] || Deas::NullLogger.new
-      @router          = a[:router] || Deas::Router.new
-      @template_source = a[:template_source] || Deas::NullTemplateSource.new
+    def status(value = nil)
+      @status = value if !value.nil?
+      @status
     end
 
-    def halt(*args);           raise NotImplementedError; end
-    def redirect(*args);       raise NotImplementedError; end
-    def content_type(*args);   raise NotImplementedError; end
-    def status(*args);         raise NotImplementedError; end
-    def headers(*args);        raise NotImplementedError; end
-    def send_file(*args);      raise NotImplementedError; end
+    def headers(value = nil)
+      @headers.merge!(value) if !value.nil?
+      @headers
+    end
 
-    # the render methods are used by both the deas and test runners
-    # so we implement here
+    def body(value = nil)
+      if !value.nil?
+        unless value.respond_to?(:each)
+          raise ArgumentError, "this body value (class `#{value.class}`), does not "\
+                               "respond to `each`."
+        end
+        @body = value
+      end
+      @body
+    end
+
+    def content_type(extname, params = nil)
+      self.headers['Content-Type'] = get_content_type(extname, params)
+    end
+
+    def halt(*args)
+      self.status(args.shift)  if args.first.instance_of?(::Fixnum)
+      self.headers(args.shift) if args.first.kind_of?(::Hash)
+      self.body(args.shift)    if args.first.respond_to?(:each)
+      throw :halt
+    end
+
+    def redirect(location, *halt_args)
+      self.status(302)
+      self.headers['Location'] = get_absolute_url(location)
+      halt(*halt_args)
+    end
+
+    def send_file(file_path, opts = nil)
+      path_name = Pathname.new(file_path)
+      self.halt(404, []) if !path_name.exist?
+
+      env   = self.request.env
+      mtime = path_name.mtime.httpdate.to_s
+      self.halt(304, []) if env['HTTP_IF_MODIFIED_SINCE'] == mtime
+      self.headers['Last-Modified'] ||= mtime
+
+      self.headers['Content-Type'] ||= get_content_type(path_name.extname)
+
+      opts ||= {}
+      disposition = opts[:disposition]
+      filename    = opts[:filename]
+      disposition ||= 'attachment' if !filename.nil?
+      filename    ||= path_name.basename
+      if !disposition.nil?
+        self.headers['Content-Disposition'] ||= "#{disposition};filename=\"#{filename}\""
+      end
+
+      sfb = SendFileBody.new(env, path_name)
+      self.body(sfb)
+      self.headers['Content-Length'] ||= sfb.size.to_s
+      self.headers['Content-Range']  ||= sfb.content_range if sfb.partial?
+      self.status(sfb.partial? ? 206 : 200)
+
+      self.halt # be consistent with halts above - `send_file` always halts
+    end
 
     def render(template_name, locals = nil)
       source_render(self.template_source, template_name, locals)
     end
 
     def source_render(source, template_name, locals = nil)
-      source.render(template_name, self.handler, locals || {})
+      self.headers['Content-Type'] ||= get_content_type(
+        File.extname(template_name),
+        'charset' => DEFAULT_CHARSET
+      )
+      self.body(source.render(template_name, self.handler, locals || {}))
     end
 
     def partial(template_name, locals = nil)
@@ -51,6 +127,19 @@ module Deas
       source.partial(template_name, locals || {})
     end
 
+    private
+
+    def get_content_type(extname, params = nil)
+      [ Rack::Mime.mime_type(extname, DEFAULT_MIME_TYPE),
+        params ? params.map{ |k,v| "#{k}=#{v}" }.join(',') : nil
+      ].compact.join(';')
+    end
+
+    def get_absolute_url(url)
+      return url if url =~ /\A[A-z][A-z0-9\+\.\-]*:/
+      File.join("#{request.env['rack.url_scheme']}://#{request.env['HTTP_HOST']}", url)
+    end
+
     class NormalizedParams
 
       attr_reader :value
@@ -73,6 +162,67 @@ module Deas
 
     end
 
+    class SendFileBody
+
+      # this class borrows from the body range handling in Rack::File.
+
+      CHUNK_SIZE = (8*1024).freeze # 8k
+
+      attr_reader :path_name, :size, :content_range
+
+      def initialize(env, path_name)
+        @path_name = path_name
+
+        file_size = @path_name.size? || Rack::Utils.bytesize(path_name.read)
+        ranges = Rack::Utils.byte_ranges(env, file_size)
+        if ranges.nil? || ranges.empty? || ranges.length > 1
+          # No ranges or multiple ranges are not supported
+          @range         = 0..file_size-1
+          @content_range = nil
+        else
+          # single range
+          @range         = ranges[0]
+          @content_range = "bytes #{@range.begin}-#{@range.end}/#{file_size}"
+        end
+
+        @size = self.range_end - self.range_begin + 1
+      end
+
+      def partial?
+        !@content_range.nil?
+      end
+
+      def range_begin; @range.begin; end
+      def range_end;   @range.end;   end
+
+      def each
+        @path_name.open("rb") do |io|
+          io.seek(@range.begin)
+          remaining_len = self.size
+          while remaining_len > 0
+            part = io.read([CHUNK_SIZE, remaining_len].min)
+            break if part.nil?
+
+            remaining_len -= part.length
+            yield part
+          end
+        end
+      end
+
+      def inspect
+        "#<#{self.class}:#{'0x0%x' % (self.object_id << 1)} " \
+          "path=#{self.path_name} " \
+          "range_begin=#{self.range_begin} range_end=#{self.range_end}>"
+      end
+
+      def ==(other_body)
+        self.path_name.to_s == other_body.path_name.to_s &&
+        self.range_begin    == other_body.range_begin    &&
+        self.range_end      == other_body.range_end
+      end
+
+    end
+
   end
 
 end

data/lib/deas/server.rb

@@ -1,6 +1,7 @@
-require 'pathname'
+require 'much-plugin'
 require 'ns-options'
 require 'ns-options/boolean'
+require 'pathname'
 require 'deas/exceptions'
 require 'deas/logger'
 require 'deas/logging'
@@ -12,19 +13,20 @@ require 'deas/template_source'
 module Deas
 
   module Server
+    include MuchPlugin
 
-    def self.included(receiver)
-      receiver.class_eval do
-        extend ClassMethods
-        include InstanceMethods
-      end
+    plugin_included do
+      extend ClassMethods
+      include InstanceMethods
     end
 
     module InstanceMethods
+
       # TODO: once Deas is no longer powered by Sinatra, this should define an
       # `initialize` method that builds a server instance.  Right now there is
       # a `new` class method that builds a SinatraApp which does this init
       # behavior
+
     end
 
     module ClassMethods
@@ -174,8 +176,8 @@ module Deas
       # server handling options
 
       option :verbose_logging, NsOptions::Boolean, :default => true
-      option :logger,                              :default => proc{ Deas::NullLogger.new }
-      option :template_source,                     :default => proc{ Deas::NullTemplateSource.new }
+      option :logger
+      option :template_source
 
       attr_accessor :settings, :init_procs, :error_procs, :template_helpers
       attr_accessor :middlewares, :router
@@ -186,8 +188,10 @@ module Deas
         # Configuration class `root`, which will not update these options as
         # expected.
         super((values || {}).merge({
-          :public_root => proc{ self.root.join('public') },
-          :views_root  => proc{ self.root.join('views') }
+          :public_root     => proc{ self.root.join('public') },
+          :views_root      => proc{ self.root.join('views') },
+          :logger          => proc{ Deas::NullLogger.new },
+          :template_source => proc{ Deas::NullTemplateSource.new(self.root) }
         }))
         @settings = {}
         @init_procs, @error_procs, @template_helpers, @middlewares = [], [], [], []

data/lib/deas/template_source.rb

@@ -75,8 +75,8 @@ module Deas
 
   class NullTemplateSource < TemplateSource
 
-    def initialize
-      super('')
+    def initialize(root = nil)
+      super(root || '')
     end
 
   end