fastr 0.0.3 → 0.1.0

data/lib/fastr/http.rb

@@ -0,0 +1,58 @@
+module Fastr
+  module HTTP
+    
+    # Parses the query string.
+    #
+    # @param qs [String]
+    # @return [Hash]
+    def self.parse_query_string(qs)
+      params = {}
+      return params if not qs
+      CGI::parse(qs).each do |k,v|
+        if v.length == 1
+          params[k] = v[0]
+        else
+          params[k] = v
+        end
+      end
+      return params
+    end
+    
+    # Builds a query string of parameters.
+    # 
+    # @param params [Hash] The parameters to put in the query string.
+    # @return [String] Query string with proper URL encoding for values.
+    def self.build_query_string(params)
+      qs = []
+      params.each do |k,v|
+        qs << "#{k}=#{CGI::escape(v)}"
+      end
+      qs.join('&')
+    end
+    
+    def self.method?(env, method)
+      return false if not env['REQUEST_METHOD']
+      return env['REQUEST_METHOD'].downcase.to_sym == method
+    end
+    
+    # Parses the HTTP cookie.
+    #
+    # @param env [Hash]
+    # @return [Hash]
+    def self.parse_cookies(env)
+      if env.has_key? "HTTP_COOKIE"
+        cookies = env['HTTP_COOKIE'].split(';')
+        c = {}
+        cookies.each do |cookie|
+          info = cookie.strip.split("=")
+          if info.length == 2
+            c[info[0].strip] = info[1].strip 
+          end
+        end
+        c
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/fastr/plugin.rb

@@ -1,9 +1,9 @@
 module Fastr
   module Plugin
     include Fastr::Log
-    
+
     PLUGIN_PATH = "custom/plugins"
-    
+
     def self.load(app)
       logger.debug "Loading plugins..."
 
@@ -11,7 +11,7 @@ module Fastr
         load_plugins_dir(app)
       end
     end
-    
+
     def self.load_plugins_dir(app)
       Dir.foreach("#{app.app_path}/#{PLUGIN_PATH}") do |filename|
         if filename != '.' and filename != '..'
@@ -19,23 +19,23 @@ module Fastr
         end
       end
     end
-    
+
     def self.load_plugin(app, name, dir)
       plugin_name = "#{name.camelcase}Plugin"
       logger.debug "Loading plugin #{plugin_name}..."
-      
+
       begin
         require("#{dir}/plugin.rb")
         m = Module.const_get(plugin_name)
-        
+
         if File.directory? "#{dir}/lib"
           Dir.glob(File.join("#{dir}/lib/**", "*.rb")).each { |f| require("#{f}") }
         end
-        
+
         app.plugins << m
       rescue => e
         logger.error "Unable to load plugin: #{e}"
       end
     end
   end
-end
+end

data/lib/fastr/router.rb

@@ -1,8 +1,27 @@
 module Fastr
+  # The router manages the routes for an application.
+  #
+  # Routes are configured in the <b>app/config/routes.rb</b> file.
+  #
+  # = Example
+  #
+  #   router.draw do |route|
+  #     route.for '/:controller/:action'
+  #     route.for '/home/:action', :action => '[A-Za-z]+'
+  #     route.for '/test', :to => 'home#index'
+  #   end
+  #
+  # @author Chris Moos
   class Router
     include Fastr::Log
     
-    attr_accessor :routes, :route_file
+    # The routes for this router.
+    # @return [Array]
+    attr_accessor :routes
+    
+    # The full path to the routes file.
+    # @return [String]
+    attr_accessor :route_file
     
     def initialize(app)
       @app = app
@@ -11,8 +30,32 @@ module Fastr
       setup_watcher
     end
     
+    # Searches the routes for a match given a Rack env.
+    #
+    # {#match} looks in the {#routes} to find a match.
+    #
+    # This method looks at PATH_INFO in +env+ to get the current request's path.
+    #
+    # == Return
+    #
+    # No Match:
+    #
+    #   {:error => :not_found}
+    #
+    # Match:
+    #
+    #   {:ok => {:controller => 'controller', :action => 'action', :var => 'value'}}
+    #
+    # @param env [Hash]
+    # @return [Hash]
     def match(env)
       self.routes.each do |info|
+        
+        # If the route didn't specify method(s) to limit by, then all HTTP methods are valid.
+        # If the route specified method(s), we check the request's HTTP method and validate
+        # that it exists in that list.
+        next unless info[:methods].nil? or info[:methods].include?(env["REQUEST_METHOD"].downcase.to_sym)
+        
         match = env['PATH_INFO'].match(info[:regex])
 
         # See if a route matches
@@ -33,6 +76,7 @@ module Fastr
       {:error => :not_found}
     end
     
+    # Loads the routes from {#route_file} and evaluates it within the context of {Fastr::Router}.
     def load
       log.debug "Loading routes from: #{self.route_file}"
       self.routes = []
@@ -41,24 +85,29 @@ module Fastr
       @app.instance_eval(file.read)
     end
     
+    # Adds a route for a path and arguments.
+    #
+    # @param path [String]
+    # @param args [Array]
     def for(path, *args)
       arg = args[0]
       log.debug "Adding route, path: #{path}, args: #{args.inspect}"
 
       match = get_regex_for_route(path, arg)
       hash = get_to_hash(arg)
+      route_info = {:regex => match[:regex], :args => arg, :vars => match[:vars], :hash => hash}
       
-      self.routes.push({:regex => match[:regex], :args => arg, :vars => match[:vars], :hash => hash})
+      # Add the HTTP methods for this route if they exist in options
+      route_info[:methods] = arg[:methods] if not arg.nil? and arg.has_key? :methods
+      
+      self.routes.push(route_info)
     end
     
+    # Evaluates the block in the context of the router.
     def draw(&block)
       block.call(self)
     end
     
-    def file_modified
-      puts "changed!"
-    end
-    
     private 
     
     def get_to_hash(args)
@@ -84,7 +133,7 @@ module Fastr
         if args.has_key? varName.to_sym
           match = args[varName.to_sym]
         end
-          regexRoute.gsub!(":#{var}", "(#{match.to_s})")
+          regexRoute.gsub!(":#{varName}", "(#{match.to_s})")
         vars.push(varName.to_sym)
       end
       {:regex => "^#{regexRoute}$", :vars => vars}

data/lib/fastr/settings.rb

@@ -1,16 +1,20 @@
-module Fastr  
+module Fastr
   class Settings
     include Fastr::Log
-    
+
     attr_accessor :cache_templates
-    
+
     def initialize(app)
       @app = app
       @cache_templates = true
     end
-    
+
     def log_level=(level)
       Fastr::Log.level = level
     end
+
+    def plugins
+      @app.plugins
+    end
   end
-end
+end

data/lib/fastr/template.rb

@@ -1,10 +1,9 @@
-require 'haml'
 require 'json'
 
 module Fastr
   module Template
-    @@tpl_cache = {}
-    
+    EXTENSIONS = {} unless defined?(EXTENSIONS)
+    TEMPLATE_CACHE = {} unless defined?(TEMPLATE_CACHE)
     
     def self.included(kls)
       kls.extend(ClassMethods)
@@ -14,37 +13,97 @@ module Fastr
       
     end
     
-    def render(type, *args)
-      method = "render_#{type}".to_sym
-      if self.respond_to? method
-        self.send(method, args)
-      else  
-        raise Exception.new("No render found for: #{type}")
-      end
+    # Finds the engine for a particular path.
+    # 
+    # ==== Parameters
+    # path<String>:: The path of the file to find an engine for.
+    #
+    # ==== Returns
+    # Class:: The engine.
+    def engine_for(path)
+      path = File.expand_path(path)      
+      EXTENSIONS[path.match(/\.([^\.]*)$/)[1]]
     end
     
-    def render_text(*args)
-      [200, {"Content-Type" => 'text/plain'}, [args[0]]]
+    # Get all known template extensions
+    #
+    # ==== Returns
+    #   Array:: Extension strings.
+    def template_extensions
+      EXTENSIONS.keys
     end
     
-    def render_json(*args)
-      [200, {"Content-Type" => 'application/json'}, args[0][0].to_json.to_s]
+    # Registers the extensions that will trigger a particular templating
+    # engine.
+    # 
+    # ==== Parameters
+    # engine<Class>:: The class of the engine that is being registered
+    # extensions<Array[String]>:: 
+    #   The list of extensions that will be registered with this templating
+    #   language
+    #
+    # ==== Raises
+    # ArgumentError:: engine does not have a compile_template method.
+    #
+    # ==== Returns
+    # nil
+    #
+    # ==== Example
+    #   Fastr::Template.register_extensions(Fastr::Template::Erubis, ["erb"])
+    def self.register_extensions(engine, extensions)
+      raise ArgumentError, "The class you are registering does not have a result method" unless
+        engine.respond_to?(:result)
+      extensions.each{|ext| EXTENSIONS[ext] = engine }
+      Fastr::Controller.class_eval <<-HERE
+        include #{engine}::Mixin
+      HERE
     end
     
-    def render_haml(args)
-      tpl = args[0][:template]
+    def render(kind, tpl, opts={})
+      # Read the cache template settings for this application, unless it is passed in
+      opts[:cache_template] = self.app.settings.cache_templates unless opts[:cache_template]
       
-      if @@tpl_cache.has_key? tpl
-        haml_engine = @@tpl_cache[tpl]
+      case kind.to_sym
+      when :template then
+        render_template(tpl, opts)
+      when :partial then
+        render_template_to_string(tpl, opts)
+      when :text then
+        render_text(tpl, opts)
+      when :json then
+        render_json(tpl, opts)
       else
-        tpl_data = File.read("app/views/#{tpl}.haml")
-        haml_engine = Haml::Engine.new(tpl_data)
-        @@tpl_cache[tpl] = haml_engine if self.app.settings.cache_templates
+        raise ArgumentError, "Unknown render type: #{kind.inspect}"
+      end
+    end
+    
+    def render_template(tpl_path, opts={})
+      self.headers['Content-Type'] = 'text/html'
+      @response_code = opts[:response_code] || 200
+      
+      [ @response_code, @headers, [render_template_to_string(tpl_path, opts)] ]
+    end
+    
+    def render_template_to_string(tpl_path, opts={})
+      unless engine = engine_for(tpl_path)
+        raise ArgumentError, "No template engine registered for #{tpl_path}"
       end
-
-      resp = haml_engine.render(self)
       
-      [200, {"Content-Type" => "text/html"}, [resp]]
+      @vars = opts[:vars] || {}
+      engine.result(tpl_path, binding(), opts[:cache_template])
+    end
+    
+    def render_text(text, opts={})
+      self.headers['Content-Type'] = 'text/plain'
+      @response_code = opts[:response_code] || 200
+      [ @response_code, @headers, [text] ]
     end
+    
+    def render_json(obj, opts={})
+      self.headers['Content-Type'] = 'application/json'
+      @response_code = opts[:response_code] || 200
+      [ @response_code, @headers, [obj.to_json.to_s] ]
+    end
+
   end
 end

data/lib/fastr/template/erubis.rb

@@ -0,0 +1,23 @@
+require 'erubis'
+
+module Fastr
+  module Template
+    class Erubis
+      
+      def self.result(tpl_path, _binding, cache_template)
+        eruby = Fastr::Template::TEMPLATE_CACHE[tpl_path]
+        unless eruby and cache_template
+          eruby = ::Erubis::Eruby.new(File.read("app/views/#{tpl_path}"))
+          Fastr::Template::TEMPLATE_CACHE[tpl_path] = eruby
+        end
+        eruby.result(_binding)
+      end
+
+      module Mixin
+      end
+
+      Fastr::Template.register_extensions(self, %w[erb])
+
+    end # Erubis
+  end # Template
+end # Fastr

data/lib/fastr/template/haml.rb

@@ -0,0 +1,23 @@
+require 'haml'
+
+module Fastr
+  module Template
+    class Haml
+      
+      def self.result(tpl_path, _binding)
+        engine = Fastr::Template::TEMPLATE_CACHE[tpl_path]
+        unless engine and cache_template
+          engine = ::Haml::Engine.new(File.read("app/views/#{tpl_path}"))
+          Fastr::Template::TEMPLATE_CACHE[tpl_path] = engine
+        end
+        engine.render(_binding)
+      end
+
+      module Mixin
+      end
+
+      Fastr::Template.register_extensions(self, %w[haml])
+
+    end # Haml
+  end # Template
+end # Fastr

data/lib/fastr/test.rb

@@ -0,0 +1,9 @@
+module Fastr
+  module Test
+    ROOT = File.expand_path(File.dirname(__FILE__))
+    
+    autoload :Controller,      "#{ROOT}/test/controller"
+    autoload :Application,     "#{ROOT}/test/application"
+    autoload :Logger,          "#{ROOT}/test/logger"
+  end
+end

data/lib/fastr/test/application.rb

@@ -0,0 +1,25 @@
+module Fastr
+  module Test
+    class Application < Fastr::Application
+      include Fastr::Log
+      
+      attr_accessor :route
+      
+      def boot
+        load_settings
+        Fastr::Plugin.load(self)
+        load_app_classes
+        setup_router
+
+        @booting = false
+        
+        plugin_after_boot
+        app_init
+      end
+      
+      def dispatch_controller(route, env)
+        super(self.route, env)
+      end
+    end
+  end
+end