doozer 0.3.1 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/doozer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{doozer}
-  s.version = "0.3.1"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["grippy"]
-  s.date = %q{2009-10-30}
+  s.date = %q{2009-11-05}
   s.default_executable = %q{doozer}
   s.description = %q{This GEM provides a small, barebones framework for creating MVC Rack applications.}
   s.email = %q{gmelton@whorde.com}
@@ -41,6 +41,7 @@ Gem::Specification.new do |s|
      "lib/doozer/initializer.rb",
      "lib/doozer/lib.rb",
      "lib/doozer/logger.rb",
+     "lib/doozer/middleware.rb",
      "lib/doozer/orm/active_record.rb",
      "lib/doozer/orm/data_mapper.rb",
      "lib/doozer/orm/sequel.rb",

data/lib/doozer.rb

@@ -27,6 +27,10 @@ module Doozer
     autoload :Route,        "doozer/exceptions"
   end
   
+  autoload :Middleware,                   "doozer/middleware"
+  autoload :MiddlewareBeforeDozerApp,     "doozer/middleware"
+
+
   autoload :Task,           "doozer/task"
   autoload :ViewHelpers,    "doozer/view_helpers"
   autoload :Version,        "doozer/version"

data/lib/doozer/app.rb

@@ -28,6 +28,8 @@ module Doozer
         route = Doozer::Routing::Routes::match(path)
         # p "path: #{path}"
         # p "route: #{route.inspect}"
+        app = nil
+        
         if not route.nil?
           if route.app.nil?
             extra_params = route.extra_params(path)
@@ -63,10 +65,13 @@ module Doozer
               r.set_cookie('flash',{:value=>nil, :path=>'/'})
               r.set_cookie('session',{:value=>controller.session_to_cookie(), :path=>'/'})
               
+              r = controller.write_response_cookies(r)
+              
+              
               # finalize the request
               controller.finished!
               controller = nil
-              return r.to_a
+              app = r.to_a
 
             rescue Doozer::Redirect => redirect
               # set the status to the one defined in the route which type of redirect do we need to handle?
@@ -82,7 +87,7 @@ module Doozer
               # finalize the request              
               controller.finished!
               controller = nil
-              return r.to_a
+              app = r.to_a
             rescue => e
               # finalize the request
               controller.finished!
@@ -95,17 +100,22 @@ module Doozer
                 end
                 logger.error("Printing env variables:")
                 logger.error(env.inspect)
-                return [500, {"Content-Type" => "text/html"}, @@errors[500]]
+                app = [500, {"Content-Type" => "text/html"}, @@errors[500]]
               else
                 raise e
               end
             end
           else
-            return route.app.call(env)
+            app = route.app.call(env)
           end
         else
-          return [404, {"Content-Type" => "text/html"}, @@errors[404]]
+          app = [404, {"Content-Type" => "text/html"}, @@errors[404]]
         end
+        
+        # pass the app through route.middleware_after if defined
+        app = route.middleware_after.new(app, {:config=>Doozer::Configs, :route=>route}).call(env) if route.middleware_after
+  
+        return app
     end
     
     def execution_time(name = nil, point = :start)

data/lib/doozer/controller.rb

@@ -24,6 +24,22 @@ module Doozer
     attr_accessor :params
     # @flash variable containing a hash of strings which are persisted in the flash cookie across the response, next request/response and then removed.
     attr_accessor :flash
+    # @cookies variable containing a hash of hashes which persit until the expiration date
+    #
+    # To save cookies: All hash keys must be symbols and value strings.
+    # Reserved hash keys per cookie:
+    # => :expires - Time.now + some duration. This default to 30 days if not defined
+    # => :path - The path for the cookie. This defaults to '/' if not defined
+    #
+    # Example:
+    # => @cookies[:yum_yum]={:a=>'123',
+    #                        :b=>'abc',
+    #                        :expires=>Time.now + 3.day
+    #                        :path=>'/path'}
+    # To delete a cookie, set it to nil or delete it from @cookies
+    #
+    # => @cookies[:testing]=nil
+    attr_accessor :cookies
     # @session variable containing a hash of strings which are persisted in the session cookie until the browser session expires.
     attr_accessor :session
     # @view variable containing a hash of string which are read from layouts.
@@ -87,12 +103,15 @@ module Doozer
       #holds all variables for template binding
       @view={}; @view[:meta]={}
       
-      #store flash
+      #loads flash messages from cookie
       @flash={}; flash_from_cookie()
       
-      #store session
+      #loads cookies from cookies
+      @cookies={}; cookies_from_cookie()
+      
+      #loads session cookie
       @session={}; session_from_cookie()
-            
+      
       #symbolize params
       @params={}; @request.params.each { |key, value| @params[key.to_sym] = value} 
       
@@ -223,7 +242,7 @@ module Doozer
 
     # Read all the session cookies and store them in the @session instance variable
     def session_from_cookie
-      #split name/value pairs and merge with flash
+      #split name/value pairs and merge into @session
       if @request.cookies
         if @request.cookies["session"]
           pairs=@request.cookies["session"].split('&')
@@ -235,6 +254,49 @@ module Doozer
       end
     end
     
+    # Read all the persistant cookies and store them in the @cookies instance variable
+    def cookies_from_cookie
+      #split name/value pairs
+      if @request.cookies
+        @request.cookies.each { | k, v |
+          if not ["flash", "session", "rack.session"].include?(k)
+            begin
+              # we need to catch cookies which don't match the key=value&key=value pattern...
+              # google analytics for example
+              values = {}
+              pairs=v.split('&')
+              pairs.each{ | pair | 
+                pair = pair.split('=')
+                values[pair[0].to_sym]=CGI::unescape(pair[1])
+              }
+              @cookies[k.to_sym] = values
+            rescue
+            end
+          end
+        }
+      end
+    end
+    
+    # Iterates all controller @cookies and writes them to the response
+    def write_response_cookies(r)
+      @cookies.each { | cookie, values |
+        if not values.nil?
+          value = []
+          path = values.delete(:path) || '/'
+          expires = values.delete(:expires) || Time.now + (60 * 60 * 24 * 30)
+          values.each { |k, v| 
+            value.push("#{k.to_s}=#{CGI::escape(v)}") if not v.nil? 
+          }
+          value = value.join('&')
+        else
+          value = ''
+          path = ''
+          expires = Time.now - 60
+        end
+        r.set_cookie(cookie.to_s,{:value=>value, :path=>path, :expires=>expires})
+      }
+      return r
+    end
     # Method for setting metatags via Controllers. 
     #
     # Pass an options hash to @view[:meta] and all the key/values are turned into metatags with the corresponding values. See Doozer::ViewHelpers#metatags for creating the metatags for view.

data/lib/doozer/middleware.rb

@@ -0,0 +1,23 @@
+module Doozer
+  class Middleware
+    def initialize(app, args=nil)
+      @app = app
+      @args = args
+    end
+    def config
+      @args[:config]
+    end
+    def logger
+      @args[:config].logger
+    end
+    def route
+      @args[:route]
+    end
+  end
+  
+  class MiddlewareBeforeDozerApp < Middleware
+    def call(env)
+      @app.call(env)
+    end
+  end
+end

data/lib/doozer/rackup/server.ru

@@ -6,6 +6,13 @@ require File.join(APP_PATH, 'config/boot')
 #--boot it up
 Doozer::Initializer.boot(env)
 
+#--load config/rack if it exists so overrides are hit for MiddlewareBeforeDozerApp
+begin
+	require "#{APP_PATH}/config/rack"
+rescue => e
+	Doozer::Configs.logger.error(e)
+end
+
 #--hookup the logger for production only since the base rackup builder doesn't load it. this avoids double logging in development
 use Rack::CommonLogger, Doozer::Configs.logger if Doozer::Configs.rack_env == :deployment
 
@@ -16,19 +23,20 @@ map "/" do
 	  use Rack::Reloader, secs=1
 	end
 	
-	use Rack::Static, {:urls => Doozer::Configs.app["static_urls"], :root => "#{APP_PATH}/#{Doozer::Configs.app["static_root"]}"} if Doozer::Configs.app
+	use Rack::Static, {:urls => Doozer::Configs.app["static_urls"], 
+	                   :root => "#{APP_PATH}/#{Doozer::Configs.app["static_root"]}"} if Doozer::Configs.app
 
 	use Rack::Session::Cookie, :key => 'rack.session',
 	                           :domain => '',
 	                           :path => '/',
 	                           :expire_after => 2592000
-	
+
+  use Doozer::MiddlewareBeforeDozerApp, {:config=>Doozer::Configs}
 	run Doozer::App.new(args=options)
 end
 
 #--stack additional rack apps
 begin
-	require "#{APP_PATH}/config/rack"
 	stack()
 rescue => e
 	Doozer::Configs.logger.error(e)

data/lib/doozer/route.rb

@@ -201,8 +201,8 @@ module Doozer
     class Route
       attr_accessor :name, :path, :controller, :action, 
                     :layout, :status, :content_type, :tokens, 
-                    :grouping, :app, :format, :view, :view_path
-                    
+                    :grouping, :app, :format, :view, :view_path,
+                    :middleware_before, :middleware_after
                     
       # Initializes a route with the following parameters
       # route - [:name, 'path', {args}]
@@ -214,6 +214,8 @@ module Doozer
         @layout = (args[:layout]) ? args[:layout] : 'default'
         @status = (args[:status]) ? args[:status] : 200
         @app=args[:app]
+        @middleware_before=args[:middleware_before]
+        @middleware_after=args[:middleware_after]
         @format = (args[:format]) ? args[:format] : :html
         #@content_type = (args[:content_type]) ? args[:content_type] : 'text/html'
         case @format

data/lib/doozer/scripts/cluster.rb

@@ -21,7 +21,7 @@ clusters = Doozer::Configs.symbolize_keys(config[:clusters])
 @server = clusters[:server]
 @config = DOOZER_PATH + '/doozer/rackup/server.ru'
 @test_config = DOOZER_PATH + '/doozer/rackup/test.rb'
-@config_file = '' #optional config file to use instead of the default unicorn config
+@config_file = '' # optional config file to use instead of the default unicorn config
 @apps = []
 
 for app in clusters[:apps]
@@ -80,6 +80,8 @@ def start_unicorn
     system(cmd)
     break
   end
+  puts "Did they start?"
+  system("ps -aux | grep unicorn")
 end
 
 # Calls stop() and then start()

data/lib/doozer/version.rb

@@ -1,8 +1,9 @@
+
 module Doozer
   module Version
     MAJOR=0
-    MINOR=3
-    PATCH=1
+    MINOR=4
+    PATCH=0
     STRING=[MAJOR, MINOR, PATCH].join('.')
   end
 end

data/templates/skeleton/config/rack.rb

@@ -11,6 +11,33 @@ class HelloWorld
   end
 end
 
+# Here's an example of how to create an after doozer app middleware
+# This class inherits Doozer::Middleware which has a few helper methods for passing Doozer::App calls on down the line
+# You can define each route to call :middleware_after=>ClassName
+# This example removes all tabs and carriage returns to slim the response
+class AfterDoozer < Doozer::Middleware
+  def call(env)
+    status, header, response = @app
+    # logger.info(self.class.to_s)
+    if route and response.is_a?(Rack::Response)
+      response.body.each{ | p | p.gsub!(/\t|^\n|^\n\n/, '') } if not [:json, :js].include?(route.format)
+    end
+    [status, header, response]
+  end
+end
+
+# This module#class is hooked into the pipeline before Doozer::App is called.
+# It inherits from Doozer::Middleware so it has access to #config but not #route
+module Doozer
+  class MiddlewareBeforeDozerApp < Doozer::Middleware
+    def call(env)
+      # puts "MiddlewareBeforeDozerApp2"
+      # logger.info("here")
+      status, header, response = @app.call(env)
+      [status, header, response]
+    end
+  end
+end
 # map additional rack apps here..
 def stack
   # map your apps here...

data/templates/skeleton/config/routes.rb

@@ -1,112 +1,108 @@
 """ 
-Drawing
-name, path w/ symbols, options={controller, action, status, formats, optional( layout, app=>HelloWorld.new)}
+Drawing Routes
 
-Name - This is the symbol you name your route. Urls generation is mapped to this key.
+Map Route
+Name - This is the symbol you name your route. Url generation is mapped to this key.
 Path - This is the url path. May contain token symbols which are exposed to the controller
 Options - 
-  controller, 
-  action, 
-  status, 
-  formats=>[:xml, json, etc],
-  layout
+  :controller=>'controller' (string)
+  :action=>'action' (string)
+  :status=>200|404|500 (int)
+  :layout=>'something_pretty' (string),
+  :formats=>[:html, :xml, json]
+  :app=>HelloWorld.new
+  :middleware_after=>HelloWorld
   
 Supports the following conventions:
-  :root      ''             :controller=>'something'
-  :articles  '/articles'     :controller=>'article', :action=>'list'
-  :article   '/article/:id'  :controller=>'article', :action=>'show'
+=> :root      ''              :controller=>'something'
+=> :articles  '/articles'     :controller=>'article', :action=>'list'
+=> :article   '/article/:id'  :controller=>'article', :action=>'show'
 
 Formats
-  Adding formats symbols automatically creates new routes for the formats symbols provided. 
-  The appropriate content-type is returned with the response.
-  You can access the format with @format in your controllers.
-  Supported formats are: :json, :js, :xml, :rss, :atom
-  All routes default to :html format
+=> Adding formats symbolzes automatically creates new routes for the formats symbols provided. 
+=> The appropriate content-type is returned with the response.
+=> You can access the format with @format in your controllers.
+=> Supported formats are: :json, :js, :xml, :rss, :atom
+=> All routes default to :html format
 
 Example:
-  
-  map.add :format_example, '/format_example', {:controller=>'index', :action=>'format_example', :status=>200, :formats=>[:json, :xml]}
-  
-  Automatically creates routes for :html, :json, and :xml with the appropriate content types
+=> map.add :format_example, '/format_example', {:controller=>'index', :action=>'format_example', :status=>200, :formats=>[:json, :xml]}
 
-  :html format (default)
-  map.add :format_example, '/format_example', {:controller=>'index', :action=>'format_example', :status=>200} 
+Automatically creates routes for :html, :json, and :xml with the appropriate content types
+  
+:html format (default)
+=> map.add :format_example, '/format_example', {:controller=>'index', :action=>'format_example', :status=>200} 
 
-  :json format
-  map.add :format_example_json, '/format_example.json', {:controller=>'index', :action=>'format_example', :status=>200}
+:json format
+=> map.add :format_example_json, '/format_example.json', {:controller=>'index', :action=>'format_example', :status=>200}
 
-  :xml format
-  map.add :format_example_xml, '/format_example.xml', {:controller=>'index', :action=>'format_example', :status=>200}
+:xml format
+=> map.add :format_example_xml, '/format_example.xml', {:controller=>'index', :action=>'format_example', :status=>200}
 
 Layouts
-  
-  All routes use the layouts/default.format.erb view. You can override this by passing the layout symbol in the options hash like this:
-  map.add :layout_example, '/layout_example', {:controller=>'index', :action=>'layout_example', :status=>200, :layout=>'other'}
+All routes use the layouts/default.format.erb view. You can override this by passing the layout symbol in the options hash like this:
+=> map.add :layout_example, '/layout_example', {:controller=>'index', :action=>'layout_example', :status=>200, :layout=>'other'}
   
 View/Layouts with Formats
-
-  If you define non-html formats you need to be aware of a few caveats.
-  
-  map.add :layout_format_example, 
+If you define non-html formats you need to be aware of a few caveats.
+=> map.add :layout_format_example, 
           '/layout_format_example', 
           {:controller=>'index', :action=>'layout_format_example', :status=>200, :layout=>'other', :formats=>[:json]}
           
-  When calling the above route with json format:
-    You will need to have a layouts/other.json.erb file along with an index/layout_format_example.json.erb file to render the view
-
-  See Doozer::Controller#render for more examples on how to override this from controllers actions.
+When calling the above route with json format:
+=> You will need to have a layouts/other.json.erb file along with an index/layout_format_example.json.erb file to render the view
+=> See Doozer::Controller#render for more examples on how to override this from controllers actions.
 
 Controller/View Helpers
 Route url generation is accessible in the following ways:
-  Defauls method for generating route urls:
-    url({:name=>:some_route ... :key=>'some value'})
+Defauls method for generating route urls:
+=> url({:name=>:some_route ... :key=>'some value'})
   -or-
-  Magic helper methods for generating route urls. The param order is taken right from the order of the parsed route tokens.
-
-    route_name_url - default html, no params
-    route_name_url(param1, params2)  - default html,  w/ params
-    route_name_format_url(param1, params2) - non html w/ params
-    
-    Example:
-      some_route_url
-      some_route_json_url(param1, param2, param3)
+=> Magic helper methods for generating route urls. The param order is taken right from the order of the parsed route tokens.
+  route_name_url - default html, no params
+  route_name_url(param1, params2)  - default html,  w/ params
+  route_name_format_url(param1, params2) - non html w/ params
+  
+  Example:
+  => some_route_url
+  => some_route_json_url(param1, param2, param3)
 
 In addition, you can also wrap the urls with a link tag like this:
-  link('anchor text', route_args, link_args)
-  Example:
-    link('homepage', {:name=>:index}, {:class=>'link_css', :id=>'home'})
-    -or-
-    link('homepage', index_url, {:class=>'link_css', :id=>'home'})
+=> link('anchor text', route_args, link_args)
+   Example:
+   => link('homepage', {:name=>:index}, {:class=>'link_css', :id=>'home'})
+      -or-
+   => link('homepage', index_url, {:class=>'link_css', :id=>'home'})
+
+Additional Rackup Apps
+You can create additional rackup apps and assign them to a route. There are two ways to hookup rack compatible apps into the response.
 
+Todo this, require the file with the rack upp here and make sure the rackup app adheres to the rack spec.
+=> require 'config/rack' # This file ships with the default app skeleton and is also loaded during doozer rackup.
 
-Not Currently Supported...
-  Magic Routes
-  This route automatically creates routes for all actions on controller 'something_not_called_fubar'
-  fubar/:action :controller=>'something_not_called_fubar'
-  This creates routes for all controller actions residing in the application.
-  :controller/:action
+1. You can assign an application which Doozer will pass your the route after is renders the route.
 
-Additional Rackup Apps
-You can create additional rackup apps and assign them to a route
+Example:
+=> map.add :fragel, '', {:controller=>'fragel', :action=>'munching', :status=>200, :middleware_after=>ClassName}
+
+2. You can bypass the Doozer controller/view by defining an application in your route definition.
 
-Just require the file here and then instantiate the class when you map the route. 
-Make sure the rackup app adheres to the rack spec.
+Todo this instantiate the class when you map the route. 
 
 Example:
+=> map.add :upload, '', {:controller=>'upload', :action=>'process', :status=>200, :app=>RackupUpload.new}
 
-require 'lib/rackup_upload'
-Doozer::Routing::Routes.draw do | map |
-  map.add :upload, '', {:controller=>'upload', :action=>'process', :status=>200, :app=>RackupUpload.new}
-end
+Bypassing Routes and Going Straight to the Rack
+=> See config/rack for example on how to bypass routing and map your own rackup apps.
 """
 
 Doozer::Routing::Routes.draw do | map | 
   
-          """ 
-          :name, 
-          :path w/ tokens, 
-          :options={:controller, :action, :status, :formats=>[:json, :xml, :js, etc], :app=>Class.new} 
-          """
+  """ 
+  :name, 
+  :path w/ tokens, 
+  :options={:controller, :action, :status, :formats=>[:json, :xml, :js, etc], :app=>Class.new or :middleware_after=>ClassName} 
+  """
   map.add :index, '', {:controller=>'index', :action=>'index', :status=>200}
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: doozer
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors: 
 - grippy
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-30 00:00:00 -07:00
+date: 2009-11-05 00:00:00 -08:00
 default_executable: doozer
 dependencies: []
 
@@ -45,6 +45,7 @@ files:
 - lib/doozer/initializer.rb
 - lib/doozer/lib.rb
 - lib/doozer/logger.rb
+- lib/doozer/middleware.rb
 - lib/doozer/orm/active_record.rb
 - lib/doozer/orm/data_mapper.rb
 - lib/doozer/orm/sequel.rb