fastr 0.0.3 → 0.1.0

data/lib/fastr/async.rb

@@ -0,0 +1,11 @@
+module Fastr
+  module Async
+    def async_resp(&blk)
+      env['async.callback'].call(blk.call)
+    end
+  
+    def render_async(resp=nil)
+      [-1, {}, []].freeze
+    end
+  end
+end

data/lib/fastr/controller.rb

@@ -1,35 +1,78 @@
 module Fastr
+  # All controllers in a Fastr application should inherit from this class.
+  #
+  # == Sample Controller
+  #
+  #   class HomeController < Fastr::Controller
+  #     def index
+  #       [200, {"Content-Type" => "text/plain"}, ["Hello, World!"]]
+  #     end
+  #   end
+  #
+  # == Response headers
+  # 
+  # You can add response headers directly by accessing the instance attribute {#headers}.
+  #
+  #   self.headers['My-Header'] = 'value'
+  #
+  #
+  # == Cookies
+  #
+  # You can access cookies in the request by accessing the instance attribute {#cookies}.
+  #
+  #   self.cookies['MYCOOKIE']
+  #
+  # == Params
+  #
+  # You can access the parameters in the request by accessing the instance attribute {#params}.
+  #
+  #   self.params['paramSentInRequest']
+  #
+  # @author Chris Moos
   class Controller
-    attr_accessor :env, :params, :app, :headers, :cookies
+    # The current Rack environment for the request.
+    #
+    # @return [Hash]
+    attr_accessor :env
+    
+    # The params for this request.
+    #
+    # @return [Hash]
+    attr_accessor :params
+    
+    # The application for the controller's current request.
+    #
+    # @return [Fastr::Application]
+    attr_accessor :app
+    
+    # Headers to send in the response.
+    #
+    # @return [Hash]
+    attr_accessor :headers
+    
+    # Cookies sent in the request
+    #
+    # @return [Hash]
+    attr_accessor :cookies
+    
+    # GET parameters.
+    #
+    # @return [Hash]
+    attr_accessor :get_params
+    
+    # POST parameters.
+    # 
+    # @return [Hash]
+    attr_accessor :post_params
     
     include Fastr::Template
     include Fastr::Deferrable
+    include Fastr::Cookie
+    include Fastr::Filter
+    include Fastr::Async
     
     def self.inherited(kls)
       kls.instance_eval('include Fastr::Log')
     end
-    
-    def set_cookie(key, value, options={})
-      cookie = ["#{key}=#{value};"]
-      
-      
-      if options.has_key? :expires and options[:expires].kind_of? Time
-        options[:expires] = options[:expires].utc.strftime('%a, %d-%b-%Y %H:%M:%S GMT')
-      end
-      
-      options.each do |k,v|
-        cookie << "#{k}=#{v.to_s};"
-      end
-      
-      
-      
-      cookie_val = cookie.join(' ')
-      
-      if self.headers['Set-Cookie'].nil?
-        self.headers['Set-Cookie'] = [cookie_val]
-      else
-        self.headers['Set-Cookie'] << cookie_val
-      end
-    end
   end
 end

data/lib/fastr/cookie.rb

@@ -0,0 +1,37 @@
+module Fastr
+  # This module adds helpers for handling cookies.
+  #
+  # == Setting a cookie
+  #
+  #   set_cookie("mycookie", "value", {:expires => Time.now + 3600})
+  #
+  # @author Chris Moos
+  module Cookie
+    # Adds a <em>Set-Cookie</em> header in the response.
+    #
+    # @param key [String]
+    # @param value [String]
+    # @option options [Time] :expires The time when the cookie should expire.
+    def set_cookie(key, value, options={})
+      cookie = ["#{key}=#{value};"]
+
+
+      if options.has_key? :expires and options[:expires].kind_of? Time
+        options[:expires] = options[:expires].utc.strftime('%a, %d-%b-%Y %H:%M:%S GMT')
+      end
+
+      # Sort the cookies alphabetically.
+      options.sort { |a,b| a.to_s <=> b.to_s }.each do |k,v|
+        cookie << "#{k}=#{v.to_s};"
+      end
+
+      cookie_val = cookie.join(' ')
+
+      if self.headers['Set-Cookie'].nil?
+        self.headers['Set-Cookie'] = [cookie_val]
+      else
+        self.headers['Set-Cookie'] << cookie_val
+      end
+    end
+  end
+end

data/lib/fastr/deferrable.rb

@@ -2,37 +2,37 @@ module Fastr
   module Deferrable
     def defer_response(code, headers, &block)
       response = DeferrableResponse.new
-      
+
       EM.next_tick do
         env['async.callback'].call([code, headers, response])
         block.call(response)
       end
-      
+
       [-1, {}, []].freeze
     end
   end
-  
+
   class DeferrableResponse
     include EventMachine::Deferrable
-    
+
     def send_data(data)
       @callback.call(data)
     end
-    
+
     def task(operation, callback)
       EM.defer(operation, callback)
     end
-    
+
     def closed(&cb)
       self.errback(&cb)
     end
-    
+
     def finish
       self.succeed
     end
-    
+
     def each(&cb)
       @callback = cb
     end
   end
-end
+end

data/lib/fastr/dispatch.rb

@@ -0,0 +1,151 @@
+module Fastr
+  module Dispatch
+    # The folder containing static content.
+    PUBLIC_FOLDER = "public"
+
+    # Convenience wrapper for do_dispatch
+    # This is the heart of the server, called indirectly by a Rack aware server.
+    #
+    # @param env [Hash]
+    # @return [Array]
+    def dispatch(env)
+      return [500, {'Content-Type' => 'text/plain'}, ["Server Not Ready"]] if @booting
+
+      begin
+        new_env = plugin_before_dispatch(env)
+        plugin_after_dispatch(new_env, do_dispatch(new_env))
+      rescue Exception => e
+        bt = e.backtrace.join("\n")
+        [500, {'Content-Type' => 'text/plain'}, ["Exception: #{e}\n\n#{bt}"]]
+      end
+    end
+
+    # Route, instantiate controller, return response from controller's action.
+    def do_dispatch(env)
+      path = env['PATH_INFO']
+
+      # Try to serve a public file
+      ret = dispatch_public(env, path)
+      return ret if not ret.nil?
+
+      log.debug "Checking for routes that match: #{path}"
+      route = router.match(env)
+
+      if route.has_key? :ok
+        dispatch_controller(route, env)
+      else
+        [404, {"Content-Type" => "text/plain"}, ["404 Not Found: #{path}"]]
+      end
+    end
+
+    def dispatch_controller(route, env)
+      vars = route[:ok]
+      controller = vars[:controller]
+      action = vars[:action].to_sym
+
+      raise Fastr::Error.new("Controller and action not present in route") if controller.nil? or action.nil?
+
+
+      klass = "#{controller.camelcase}Controller"
+
+      log.info "Routing to controller: #{klass}, action: #{action}"
+
+      klass_inst = Module.const_get(klass)
+      obj = klass_inst.new
+      setup_controller(obj, env, vars)
+
+      # Run before filters
+      response = Fastr::Filter.run_before_filters(obj, klass_inst, action)
+
+      # No before filters halted, send to action
+      if response.nil?
+        response = obj.send(action)
+      end
+
+      # Run after filters
+      response = Fastr::Filter.run_after_filters(obj, klass_inst, action, response)
+
+      code, hdrs, body = *response
+
+      # Merge headers with anything specified in the controller
+      hdrs.merge!(obj.headers)
+
+      [code, hdrs, body]
+    end
+
+    def dispatch_public(env, path)
+      path = "#{self.app_path}/#{PUBLIC_FOLDER}/#{path[1..(path.length - 1)]}"
+      if not File.directory? path and File.exists? path
+        f = File.open(path)
+        hdrs = {}
+
+        type = MIME::Types.type_for(File.basename(path))
+
+        if not type.nil?
+            hdrs["Content-Type"] = type[0].to_s
+        end
+
+        return [200, hdrs, [f.read]]
+      else
+        return nil
+      end
+    end
+
+    # Sets up a controller for a request.
+    def setup_controller(controller, env, vars)
+      controller.env = env
+      controller.headers = {}
+
+      setup_controller_params(controller, env, vars)
+
+      controller.cookies = Fastr::HTTP.parse_cookies(env)
+      controller.app = self
+    end
+
+    # Populate the parameters based on the HTTP method.
+    def setup_controller_params(controller, env, vars)
+      if Fastr::HTTP.method?(env, :get)
+        controller.get_params = Fastr::HTTP.parse_query_string(env['QUERY_STRING'])
+        controller.params = controller.get_params.merge(vars)
+      elsif Fastr::HTTP.method?(env, :post)
+        controller.post_params = {}
+        controller.post_params = Fastr::HTTP.parse_query_string(env['rack.input'].read) if env['rack.input']
+        controller.params = controller.post_params.merge(vars)
+      else
+        controller.params = vars
+      end
+    end
+
+    # Runs before_dispatch in all plugins.
+    #
+    # @param env [Hash]
+    # @return [Hash]
+    def plugin_before_dispatch(env)
+      new_env = env
+
+      self.plugins.each do |plugin|
+        if plugin.respond_to? :before_dispatch
+          new_env = plugin.send(:before_dispatch, self, env)
+        end
+      end
+
+      new_env
+    end
+
+    # Runs after_dispatch in all plugins.
+    #
+    # @param env [Hash]
+    # @return [Hash]
+    def plugin_after_dispatch(env, response)
+      new_response = response
+
+      self.plugins.each do |plugin|
+        if plugin.respond_to? :after_dispatch
+          new_response = plugin.send(:after_dispatch, self, env, response)
+        end
+      end
+
+      new_response
+    end
+  end
+end

data/lib/fastr/extensions/string.rb

@@ -7,4 +7,12 @@ class String
     
     newStr.join('')
   end
+  
+  def uncamelcase
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
 end

data/lib/fastr/filter.rb

@@ -1,17 +1,123 @@
 module Fastr
-  module Filter
+  module Filter        
+    include Fastr::Log
+    
     def self.included(kls)
-      
       kls.extend(ClassMethods)
-      puts kls
-      puts kls.instance_variable_get(:@filters).inspect
+    end
+    
+    # Run through all the before filters and maybe return a response.
+    #
+    # @param controller [Fastr::Controller] The controller instance for the action
+    # @param klass [Class] The controller class for the action
+    # @param action [Symbol] The action that the filters should run for
+    # @param response [Array] 
+    # @return [Hash] The new response
+    def self.run_before_filters(controller, klass, action)
+      new_response = nil
+      get_filters_for_action(klass, :before, action).each do |filter|
+        new_response = execute_filter(filter, controller)
+      end
+      new_response
+    end
+    
+    # Run the response through all after filters and return the new response.
+    #
+    # @param controller [Fastr::Controller] The controller instance for the action
+    # @param klass [Class] The controller class for the action
+    # @param action [Symbol] The action that the filters should run for
+    # @param response [Array] 
+    # @return [Array] The new response
+    def self.run_after_filters(controller, klass, action, response)
+      new_response = response
+      get_filters_for_action(klass, :after, action).each do |filter|
+        new_response = execute_filter(filter, controller, new_response)
+      end
+      new_response
+    end
+    
+    # Executes a filter.
+    # 
+    # @param filter [Hash]
+    # @param obj [Object]
+    # @param args
+    # @return [Object]
+    def self.execute_filter(filter, obj, *args)
+      if args.length == 0
+        state = nil
+      else
+        state = *args
+      end
+      
+      filter[:methods].each do |method|
+        if args.length == 0
+          state = obj.send(method)
+        else
+          state = obj.send(method, state)
+        end
+      end
+      
+      return state
+    end
+    
+    # Get all the filters for an action.
+    #
+    # @param klass [Class] The class for the action
+    # @param type [Symbol] Type of filters
+    # @param action [Symbol] The action for the class
+    # @return [Array]
+    def self.get_filters_for_action(klass, type, action)
+      get_filters(klass, type).find_all { |f| run_filter?(f, action) }
+    end
+    
+    # Gets the filters for a class.
+    #
+    # @param klass [Class] The class to get the filters from
+    # @param type [Symbol] The type of filters to get
+    # @return [Array]
+    def self.get_filters(klass, type)
+      filter_var = "@filters_#{type}".to_sym
+      if klass.instance_variable_defined? filter_var
+        return klass.instance_variable_get(filter_var)
+      else
+        return []
+      end
+    end
+    
+    
+    
+    def self.run_filter?(filter, action)
+      return true if filter.has_key? :all and filter[:all] == true
+      return true if filter.has_key? :only and filter[:only].include? action
+      return true if filter.has_key? :except and not filter[:except].include? action
+      return false
+    end
+    
+    # Halt the filter chain and return a response.
+    # @param response [Hash] Rack response
+    def filter_stop(response)
+      response
+    end
+    
+    # Continue through the filter chain
+    def filter_continue
+      nil
     end
     
     module ClassMethods
       def before_filter(*args)
+        add_filter(:before, *args)
+      end
+      
+      def after_filter(*args)
+        add_filter(:after, *args)
+      end
+      
+      private
+      
+      def add_filter(type, *args)
         methods = []
         options = {}
-        puts self
         args.each do |arg|
           if arg.kind_of? Symbol
             methods << arg
@@ -19,16 +125,17 @@ module Fastr
             options = arg
           end
         end
-        
-        setup_filter(methods, options)
+        setup_filter(methods, options, type)
       end
       
-      def setup_filter(methods, options)
-        if self.instance_variable_defined? :@filters
-          f = self.instance_variable_get(:@filters)
+      def setup_filter(methods, options, type)
+        filter_var = "@filters_#{type}".to_sym
+        
+        if self.instance_variable_defined? filter_var
+          f = self.instance_variable_get(filter_var)
         else
           f = []
-          self.instance_variable_set(:@filters, f)
+          self.instance_variable_set(filter_var, f)
         end
 
         if options.has_key? :only and options[:only].kind_of? Array