mack 0.5.5.4 → 0.6.0

data/lib/routing/route_map.rb

@@ -1,4 +1,3 @@
-require 'singleton'
 module Mack
   
   module Routes
@@ -8,7 +7,7 @@ module Mack
     # See Mack::Routes::RouteMap for more information.
     def self.build
       yield Mack::Routes::RouteMap.instance
-      Mack::Routes::Urls.include_safely_into(Mack::Controller::Base, 
+      Mack::Routes::Urls.include_safely_into(Mack::Controller, 
                                              Mack::Rendering::ViewTemplate, 
                                              Test::Unit::TestCase, 
                                              Mack::Distributed::Routes::Urls)
@@ -129,12 +128,25 @@ module Mack
     #   hello_world_url # => "/"
     #   hello_world_full_url # => "http://example.org/"
     # These methods act just like the ones created when you use the resource method.
+    # 
+    # === Exception Routes:
+    # You can define a route that will catch exceptions that are raised in other controllers.
+    # 
+    #   Mack::Routes.build do |r|
+    #     r.handle_error Mack::ResourceNotFound, :controller => :oops, :action => :404
+    #     r.handle_error HollyCrapError, :controller => :oops, :action => :500
+    #   end
+    # In the example if an action raises a Mack::ResourceNotFound it will be caught and rendered
+    # using the OopsController and the 404 action.
+    # If A HollyCrapError is thrown it will be caught and rendered using the OopsController and the 500 action.
+    # You can catch all exceptions using Exception.
     class RouteMap
       include Singleton
       
       def initialize # :nodoc:
         @routes_list = []
         @default_routes_list = []
+        @handle_error_routes = {}
       end
       
       # Creates 'Rails' style default mappings:
@@ -158,7 +170,6 @@ module Mack
       
       # Sets up mappings and named routes for a resource.
       def resource(controller)
-        
         connect_with_named_route("#{controller}_index", "/#{controller}", {:controller => controller, :action => :index, :method => :get})
         connect_with_named_route("#{controller}_create", "/#{controller}", {:controller => controller, :action => :create, :method => :post})
         connect_with_named_route("#{controller}_new", "/#{controller}/new", {:controller => controller, :action => :new, :method => :get})
@@ -168,6 +179,10 @@ module Mack
         connect_with_named_route("#{controller}_delete", "/#{controller}/:id", {:controller => controller, :action => :delete, :method => :delete})
       end
       
+      def handle_error(error, options = {})
+        @handle_error_routes[error] = options
+      end
+      
       def method_missing(sym, *args) # :nodoc:
         connect_with_named_route(sym, args.first, args.last)
       end
@@ -182,7 +197,7 @@ module Mack
         unless pattern == "/"
           pattern.chop! if pattern.match(/\/$/)
         end
-        meth = (req.params("_method") || req.request_method.downcase).to_sym
+        meth = (req.params["_method"] || req.request_method.downcase).to_sym
         rt = routes_list.dup
         rt << @default_routes_list.dup
         rt.flatten!
@@ -202,6 +217,12 @@ module Mack
         raise Mack::Errors::UndefinedRoute.new(req)
       end # get
       
+      # Given an error class name it will return a routing options Hash, or nil, if one
+      # has not been mapped.
+      def get_route_from_error(error)
+        @handle_error_routes[error]
+      end
+      
       attr_reader :routes_list # :nodoc:
       
       private
@@ -212,7 +233,8 @@ module Mack
         # if the pattern doesn't start with /, then add it.
         pattern = "/" << pattern unless pattern.match(/^\//)
         pt = pattern.downcase
-        Route.new(pt, regex_from_pattern(pt), meth, options)
+        route = Route.new(pt, regex_from_pattern(pt), meth, options)
+        route
       end
       
       def connect_with_named_route(n_route, pattern, options = {})

data/lib/routing/urls.rb

@@ -17,6 +17,7 @@ module Mack
       #     # => "/blog/1?n_id=2
       def url_for_pattern(url, options = {})
         u = url.dup
+        u = "/" if url.blank?
         unused_params = []
         format = nil
         options.each_pair do |k, v|

data/lib/runner.rb

@@ -1,3 +1,4 @@
+require File.join(File.dirname(__FILE__), 'routing', 'urls')
 module Mack
   # This is the heart and soul of the Mack framework! This class interfaces with the Rack framework.
   # It handles all the dispatching back and forth between the Rack framework and a Mack application.
@@ -19,27 +20,59 @@ module Mack
               # because the route is specified to be a redirect, let's do that:
               redirect_to(route)
             else
-              # let's handle a normal request:
-              begin
-                cont = "#{route[:controller].to_s.camelcase}Controller".constantize
-              rescue NameError => e
-                raise Mack::Errors::ResourceNotFound.new(self.request.path_info)
+              self.request.all_params[:original_controller] = route[:controller]
+              self.request.all_params[:original_action] = route[:action]
+              run_controller(route)
+            end
+          # rescue Mack::Errors::ResourceNotFound, Mack::Errors::UndefinedRoute => e
+          #   return try_to_find_resource(env, e)
+          rescue Exception => e
+            route = Mack::Routes::RouteMap.instance.get_route_from_error(e.class)
+            unless route.nil?
+              run_controller(route, e)
+            else
+              if e.class == Mack::Errors::ResourceNotFound || e.class == Mack::Errors::UndefinedRoute
+                return try_to_find_resource(env, e)
+              else
+                raise e
               end
-              c = cont.new(self.request, self.response, self.cookies)
-              self.response.controller = c
-              self.response.write(c.run)
             end
-          rescue Mack::Errors::ResourceNotFound, Mack::Errors::UndefinedRoute => e
-            return try_to_find_resource(env, e)
           end
         end # setup
       rescue Exception => e
-        MACK_DEFAULT_LOGGER.error(e)
+        Mack.logger.error(e)
         raise e
       end
     end
     
-    private
+    #--
+    # This method gets called after the session has been established. Override this method
+    # to add custom code around requests.
+    # def custom_dispatch_wrapper
+    #   yield
+    # end
+    #++
+    
+    #private
+    def run_controller(route, e = nil)
+      # let's handle a normal request:
+      begin
+        cont = "#{route[:controller].to_s.camelcase}Controller".constantize
+      rescue NameError => e
+        raise Mack::Errors::ResourceNotFound.new(self.request.path_info)
+      end
+      self.request.all_params[:controller] = route[:controller]
+      self.request.all_params[:action] = route[:action]
+      self.request.instance_variable_set("@params_controller", nil)
+      self.request.instance_variable_set("@params_action", nil)
+      
+      c = cont.new(self.request, self.response, self.cookies)
+      c.caught_exception = e unless e.nil?
+
+      self.response.controller = c
+      self.response.write(c.run)
+    end
+    
     def log_request
       s_time = Time.now
       x = yield
@@ -48,12 +81,12 @@ module Mack
       if app_config.log.detailed_requests
         msg = "\n\t[#{@request.request_method.upcase}] '#{@request.path_info}'\n"
         msg << "\tSession ID: #{@request.session.id}\n"
-        msg << "\tParameters: #{@request.all_params.inspect}\n"
+        msg << "\tParameters: #{@request.all_params}\n"
         msg << "\tCompleted in #{p_time} (#{(1 / p_time).round} reqs/sec) | #{@response.status} [#{@request.full_host}]"
       else
         msg = "[#{@request.request_method.upcase}] '#{@request.path_info}' (#{p_time})"
       end
-      MACK_DEFAULT_LOGGER.info(msg)
+      Mack.logger.info(msg)
       x
     end
     
@@ -67,7 +100,9 @@ module Mack
         @cookies = Mack::CookieJar.new(self.request, self.response)
         session do
           begin
-            yield
+            # custom_dispatch_wrapper do
+              yield
+            # end
           rescue Exception => e
             exception = e
           end
@@ -111,8 +146,8 @@ module Mack
       if File.extname(env["PATH_INFO"]).blank?
         env["PATH_INFO"] << ".html"
       end
-      if File.exists?(File.join(Mack::Configuration.public_directory, env["PATH_INFO"]))
-        return Rack::File.new(File.join(Mack::Configuration.public_directory)).call(env)
+      if File.exists?(File.join(Mack.root, "public", env["PATH_INFO"]))
+        return Rack::File.new(File.join(Mack.root, "public")).call(env)
       else
         raise exception
       end

data/lib/tasks/cachetastic_tasks.rake

@@ -10,7 +10,7 @@ namespace :cachetastic do
       when "All"
         puts "About to work on ALL caches!"
         # force all caches to register themselves:
-        ["#{Mack::Configuration.root}/lib/caches"].each do |dir|
+        ["#{Mack.root}/lib/caches"].each do |dir|
           Find.find(dir) do |f|
             # puts f
             if FileTest.directory?(f) and !f.match(/.svn/)
@@ -48,7 +48,7 @@ namespace :cachetastic do
     rescue MethodNotImplemented => e
       msg = "Cachetastic.rake Warning: cache #{cache} does not implement #{action}. This is probably an error."
       puts msg
-      MACK_DEFAULT_LOGGER.warning(msg)
+      Mack.logger.warning(msg)
     rescue NoMethodError => e
     rescue Exception => e
       raise e

data/lib/tasks/mack_server_tasks.rake

@@ -12,20 +12,18 @@ namespace :mack do
       require 'fileutils'
 
       require 'thin'
-      
-      Mack::Configuration.set(:root, FileUtils.pwd) if Mack::Configuration.root.nil?
 
       options = OpenStruct.new
       options.port = (ENV["PORT"] ||= "3000") # Does NOT work with Thin!! You must edit the thin.yml file!
       options.handler = (ENV["HANDLER"] ||= "thin")
 
 
-      # require File.join(Mack::Configuration.root, "config", "boot.rb")
+      # require File.join(Mack.root, "config", "boot.rb")
       require 'mack'
 
       if options.handler == "thin"
         # thin_opts = ["start", "-r", "config/thin.ru"]
-        thin_opts = ["start", "-C", "config/thin.yml"]
+        thin_opts = ["start"]
         Thin::Runner.new(thin_opts.flatten).run!
       else
         Mack::SimpleServer.run(options)

data/lib/tasks/mack_update_tasks.rake

@@ -0,0 +1,26 @@
+namespace :mack do
+  
+  namespace :update do
+    
+  #   desc "Renames thin.ru to rackup.ru and updates your thin.yml, if necessary."
+  #   task :rackup do
+  #     require 'fileutils'
+  #     ru = File.join(Mack.root, "config", "thin.ru")
+  #     if File.exists?(ru)
+  #       FileUtils.mv(ru, File.join(Mack.root, "config", "rackup.ru"))
+  #     end
+  #     thin_yml = File.join(Mack.root, "config", "thin.yml")
+  #     if File.exists?(thin_yml)
+  #       contents = File.open(thin_yml).read
+  #       contents.gsub!("thin.ru", "rackup.ru")
+  #       File.open(thin_yml, "w") do |f|
+  #         f.puts contents
+  #       end
+  #     end
+  #   end
+  
+  end
+  
+end
+
+# alias_task "mack:update", "mack:update:rackup"

data/lib/tasks/rake_rules.rake

@@ -1,6 +1,6 @@
 rule /\#.*/ do |t|
   env = t.name.match(/\#.*/).to_s.gsub("#", "")
-  Mack::Configuration.set(:env, env)
+  ENV["MACK_ENV"] = env
   name = t.name.gsub("##{env}", "")
   Rake::Task[name].invoke
 end
@@ -22,4 +22,8 @@ rule /^generate:/ do |t|
   Rake::Task["environment"].invoke
   klass = "#{klass.camelcase}Generator"
   gen = klass.constantize.run(ENV.to_hash)
-end
+end
+
+rule /^test:rspec/ do |t|
+  raise "i'm running a test task!"
+end

data/lib/tasks/test_tasks.rake

@@ -1,16 +1,31 @@
-desc "Run test code."
-Rake::TestTask.new(:default) do |t|
-  # Rake::Task["log:clear"].invoke
-  t.libs << "test"
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
+require 'rake'
+require 'pathname'
+require 'spec'
+require 'spec/rake/spectask'
 
 namespace :test do
   
+  task :setup do
+  end
+  
+  desc "Run test code."
+  Rake::TestTask.new(:test_case) do |t|
+    t.libs << "test"
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = true
+  end
+  
+  desc 'Run specifications'
+  Spec::Rake::SpecTask.new(:rspec) do |t|
+    t.spec_opts << '--options' << 'test/spec.opts' if File.exists?('test/spec.opts')
+    t.spec_files = Dir.glob('test/**/*_spec.rb')
+  end
+  
   desc "Report code statistics (KLOCs, etc) from the application. Requires the rcov gem."
   task :stats do |t|
-    x = `rcov test/**/*_test.rb -T --no-html -x Rakefile,config\/`
+    ENV["MACK_ENV"] = "test"
+    Rake::Task["mack:environment"].invoke
+    x = `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -T --no-html -x Rakefile,config\/`
     @print = false
     x.each do |line|
       puts line if @print
@@ -24,7 +39,9 @@ namespace :test do
   
   desc "Generates test coverage from the application. Requires the rcov gem."
   task :coverage do |t|
-    `rcov test/**/*_test.rb -x Rakefile,config\/`
+    ENV["MACK_ENV"] = "test"
+    Rake::Task["mack:environment"].invoke
+    `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -x Rakefile,config\/`
     `open coverage/index.html`
   end
   
@@ -38,6 +55,7 @@ namespace :test do
   
 end
 
-alias_task :test, :default
+
+alias_task :default, ["test:setup", "test:rspec"]
 alias_task :stats, "test:stats"
 alias_task :coverage, "test:coverage"

data/lib/testing/helpers.rb

@@ -0,0 +1,187 @@
+require "test/unit"
+
+module Mack
+  module Testing # :nodoc:
+    module Helpers
+    
+      # Runs the given rake task. Takes an optional hash that mimics command line parameters.
+      def rake_task(name, env = {}, tasks = [])
+        # set up the Rake application
+        rake = Rake::Application.new
+        Rake.application = rake
+      
+        [File.join(File.dirname(__FILE__), "..", "mack_tasks.rb"), tasks].flatten.each do |task|
+          load(task)
+        end
+      
+        # save the old ENV so we can revert it
+        old_env = ENV.to_hash
+        # add in the new ENV stuff
+        env.each_pair {|k,v| ENV[k.to_s] = v}
+      
+        begin
+          # run the rake task
+          rake[name].invoke
+        
+          # yield for the tests
+          yield if block_given?
+        
+        rescue Exception => e
+          raise e
+        ensure
+          # empty out the ENV
+          ENV.clear
+          # revert to the ENV before the test started
+          old_env.to_hash.each_pair {|k,v| ENV[k] = v}
+
+          # get rid of the Rake application
+          Rake.application = nil
+        end
+      end
+    
+      # Temporarily changes the application configuration. Changes are reverted after
+      # the yield returns.
+      def temp_app_config(options = {})
+        app_config.load_hash(options, String.randomize)
+        yield
+        app_config.revert
+      end
+    
+      def remote_test # :nodoc:
+        if (app_config.run_remote_tests)
+          yield
+        end
+      end
+    
+      # Retrieves an instance variable from the controller from a request.
+      def assigns(key)
+        $mack_app.instance_variable_get("@app").instance_variable_get("@response").instance_variable_get("@controller").instance_variable_get("@#{key}")
+      end
+
+      # Performs a 'get' request for the specified uri.
+      def get(uri, options = {})
+        build_response(request.get(uri, build_request_options(options)))
+      end
+    
+      # Performs a 'put' request for the specified uri.
+      def put(uri, options = {})
+        build_response(request.put(uri, build_request_options({:input => options.to_params})))
+      end
+    
+      # Performs a 'post' request for the specified uri.
+      def post(uri, options = {})
+        build_response(request.post(uri, build_request_options({:input => options.to_params})))
+      end
+    
+      # Performs a 'delete' request for the specified uri.
+      def delete(uri, options = {})
+        build_response(request.delete(uri, build_request_options(options)))
+      end
+    
+      # Returns a Rack::MockRequest. If there isn't one, a new one is created.
+      def request
+        @request ||= Rack::MockRequest.new(mack_app)
+      end
+    
+      # Returns the last Rack::MockResponse that got generated by a call.
+      def response
+        @testing_response
+      end
+    
+      # Returns all the Rack::MockResponse objects that get generated by a call.
+      def responses
+        @responses
+      end
+    
+      # Returns a Mack::Session from the request.
+      def session # :nodoc:
+        Cachetastic::Caches::MackSessionCache.get(cookies[app_config.mack.session_id]) do
+          id = String.randomize(40).downcase
+          set_cookie(app_config.mack.session_id, id)
+          sess = Mack::Session.new(id)
+          Cachetastic::Caches::MackSessionCache.set(id, sess)
+          sess
+        end
+      end
+    
+      # Used to create a 'session' around a block of code. This is great of 'integration' tests.
+      def in_session
+        @_mack_in_session = true
+        clear_session
+        yield
+        clear_session
+        @_mack_in_session = false
+      end
+    
+      # Clears all the sessions.
+      def clear_session
+        Cachetastic::Caches::MackSessionCache.expire_all
+      end
+    
+      # Returns a Hash of cookies from the response.
+      def cookies
+        test_cookies
+      end
+    
+      # Sets a cookie to be used for the next request
+      def set_cookie(name, value)
+        test_cookies[name] = value
+      end
+    
+      # Removes a cookie.
+      def remove_cookie(name)
+        test_cookies.delete(name)
+      end
+    
+      private
+      def test_cookies
+        @test_cookies = {} if @test_cookies.nil?
+        @test_cookies
+      end
+    
+      def mack_app
+        if $mack_app.nil?
+          $mack_app = Rack::Recursive.new(Mack::Runner.new)
+        end
+        $mack_app
+      end
+    
+      def build_request_options(options)
+        {"HTTP_COOKIE" => test_cookies.join("%s=%s", "; ")}.merge(options)
+      end
+    
+      def build_response(res)
+        @responses = [res]
+        strip_cookies_from_response(res)
+        # only retry if it's a redirect request
+        if res.redirect? 
+          until res.successful?
+            [res].flatten.each do |r|
+              strip_cookies_from_response(r)
+            end
+            res = request.get(res["Location"])
+            @responses << res
+          end
+        end
+        @testing_response = Mack::Testing::Response.new(@responses)
+      end
+    
+      def strip_cookies_from_response(res)
+        unless res.original_headers["Set-Cookie"].nil?
+          res.original_headers["Set-Cookie"].each do |ck|
+            spt = ck.split("=")
+            name = spt.first
+            value = spt.last
+            if name == app_config.mack.session_id
+              value = nil unless @_mack_in_session
+            end
+            set_cookie(name, value)
+          end
+        end
+      end
+    
+    end # Helpers
+  end # Testing
+end # Mack
+
+Test::Unit::TestCase.send(:include, Mack::Testing::Helpers)