mack 0.6.0.1 → 0.6.1

data/lib/{routing → mack/routing}/route_map.rb

@@ -1,6 +1,7 @@
 module Mack
   
   module Routes
+    include Extlib::Hook
     
     # This method yields up Mack::Routes::RouteMap and allows for the creation of routes in the system.
     # 
@@ -11,13 +12,6 @@ module Mack
                                              Mack::Rendering::ViewTemplate, 
                                              Test::Unit::TestCase, 
                                              Mack::Distributed::Routes::Urls)
-      if app_config.mack.use_distributed_routes
-        raise Mack::Distributed::Errors::ApplicationNameUndefined.new if app_config.mack.distributed_app_name.nil?
-        
-        d_urls = Mack::Distributed::Routes::Urls.new(app_config.mack.distributed_site_domain)
-        d_urls.put
-      end
-      # puts "Finished compiling routes: #{Mack::Routes::RouteMap.instance.routes_list.inspect}"
     end
     
     # Routes are the back bone of the Mack framework. They are used to map incoming urls to controllers.

data/lib/mack/runner.rb

@@ -0,0 +1,121 @@
+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.
+  class Runner
+    include Extlib::Hook
+    include Mack::Routes::Urls
+    
+    attr_reader :response # :nodoc:
+    attr_reader :request # :nodoc:
+    attr_reader :cookies # :nodoc:
+    attr_reader :runner_helpers # :nodoc:
+    
+    # This method needs to be defined as part of the Rack framework. As is noted for the Mack::Runner
+    # class, this is where the center of the Mack framework lies.
+    def call(env)
+      begin
+        setup(env)
+        begin
+          route = Mack::Routes::RouteMap.instance.get_route_from_request(self.request)
+          if route[:redirect_to]
+            # because the route is specified to be a redirect, let's do that:
+            redirect_to(route)
+          else
+            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
+          end
+        end
+        teardown
+      rescue Exception => e
+        Mack.logger.error(e)
+        raise e
+      end
+    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
+      c.configure_controller(self.request, self.response, self.cookies)
+      c.caught_exception = e unless e.nil?
+
+      self.response.controller = c
+      self.response.write(c.run)
+    end
+    
+    # Setup the request, response, cookies, session, etc...
+    # yield up, and then clean things up afterwards.
+    def setup(env)
+      @request = Mack::Request.new(env) 
+      @response = Mack::Response.new
+      @cookies = Mack::CookieJar.new(self.request, self.response)
+      @runner_helpers = []
+      Mack::RunnerHelpers::Registry.registered_items.each do |helper|
+        help = helper.new
+        help.start(self.request, self.response, self.cookies)
+        @runner_helpers << help
+      end
+    end
+    
+    def teardown
+      self.runner_helpers.reverse.each do |help|
+        help.complete(self.request, self.response, self.cookies)
+      end
+      self.response.finish
+    end
+    
+    def try_to_find_resource(env, exception)
+      env = env.dup
+      # we can't find a route for this, so let's try and see if it's in the public directory:
+      if File.extname(env["PATH_INFO"]).blank?
+        env["PATH_INFO"] << ".html"
+      end
+      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
+    end
+    
+    # This will redirect the request to the specified url. A default status of
+    # 302, Moved Temporarily, is set if no status is specified. A simple HTML
+    # page is rendered in case the redirect does not occur.
+    def redirect_to(route)
+      status = route[:status] || 302
+      url = route[:redirect_to]
+      options = self.request.all_params
+      options.merge!(route)
+      options - [:controller, :action, :redirect_to, :method, :status, :format]
+      url = url_for_pattern(url, options)
+      self.response.status = status
+      self.response[:location] = url
+      self.response.write(redirect_html(self.request.path_info, url, status))
+    end
+    
+  end
+end

data/lib/mack/runner_helpers/base.rb

@@ -0,0 +1,13 @@
+module Mack
+  module RunnerHelpers # :nodoc:
+    class Base
+      
+      def start(request, response, cookies)
+      end
+      
+      def complete(request, response, cookies)
+      end
+      
+    end # Base
+  end # RunnerHelpers
+end # Mack

data/lib/mack/runner_helpers/registry.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), "request_logger")
+require File.join(File.dirname(__FILE__), "session")
+module Mack
+  module RunnerHelpers
+    class Registry < Mack::Utils::RegistryList
+      
+      def initial_state
+        [Mack::RunnerHelpers::RequestLogger, Mack::RunnerHelpers::Session]
+      end
+      
+    end
+  end
+end

data/lib/mack/runner_helpers/request_logger.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), "base")
+module Mack
+  module RunnerHelpers # :nodoc:
+    class RequestLogger < Mack::RunnerHelpers::Base
+      
+      attr_reader :start_time
+      attr_reader :end_time
+      attr_reader :total_time
+      attr_reader :requests_per_second
+      
+      def start(request, response, cookies)
+        @start_time = Time.now
+      end
+      
+      def complete(request, response, cookies)
+        @end_time = Time.now
+        @total_time = @end_time - @start_time
+        @requests_per_second = (1 / @total_time).round
+        if app_config.log.detailed_requests
+          msg = "\n\t[#{request.request_method.upcase}] '#{request.path_info}'\n"
+          msg << "\tSession ID: #{request.session.id}\n" if app_config.mack.use_sessions
+          msg << "\tParameters: #{request.all_params}\n"
+          msg << Mack::Utils::Ansi::Color.wrap(app_config.log.completed_color, "\tCompleted in #{@total_time} (#{@requests_per_second} reqs/sec) | #{response.status} [#{request.full_host}]")
+        else
+          msg = "[#{request.request_method.upcase}] '#{request.path_info}' (#{total_time})"
+        end
+        Mack.logger.info(msg)
+      end
+      
+    end # RequestLogger
+  end # RunnerHelpers
+end # Mack

data/lib/mack/runner_helpers/session.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), "base")
+module Mack
+  module RunnerHelpers # :nodoc:
+    class Session < Mack::RunnerHelpers::Base
+      
+      attr_accessor :sess_id
+      
+      def start(request, response, cookies)
+        if app_config.mack.use_sessions
+          sess_id = cookies[app_config.mack.session_id]
+          unless sess_id
+            sess_id = create_new_session(request, response, cookies)
+          else
+            sess = Cachetastic::Caches::MackSessionCache.get(sess_id)
+            if sess
+              request.session = sess
+            else
+              # we couldn't find it in the store, so we need to create it:
+              sess_id = create_new_session(request, response, cookies)
+            end
+          end
+        end
+      end
+      
+      def complete(request, response, cookies)
+        Cachetastic::Caches::MackSessionCache.set(sess_id, request.session) if app_config.mack.use_sessions
+      end
+      
+      private
+      def create_new_session(request, response, cookies)
+        id = String.randomize(40).downcase
+        cookies[app_config.mack.session_id] = {:value => id, :expires => nil}
+        sess = Mack::Session.new(id)
+        request.session = sess
+        Cachetastic::Caches::MackSessionCache.set(id, sess)
+        id
+      end
+      
+    end # Session
+  end # RunnerHelpers
+end # Mack

data/lib/{tasks → mack/tasks}/cachetastic_tasks.rake

@@ -55,15 +55,4 @@ namespace :cachetastic do
     end
   end
   
-  # namespace :page_cache do
-  #   
-  #   desc "Expires the page cache."
-  #   task :expire_all => :environment do
-  #     running_time do("Cachetastic::Caches::PageCache.expire_all")
-  #       Cachetastic::Caches::PageCache.expire_all
-  #     end
-  #   end
-  #   
-  # end
-  
 end

data/lib/{tasks → mack/tasks}/gem_tasks.rake

@@ -1,34 +1,20 @@
 namespace :gems do
   
   desc "lists all the gem required for this application."
-  task :list => :setup do
+  task :list do
     Mack::Utils::GemManager.instance.required_gem_list.each do |g|
       puts g
     end
   end # list
   
   desc "installs the gems needed for this application."
-  task :install => :setup do
-    runner = Gem::GemRunner.new
+  task :install do
     Mack::Utils::GemManager.instance.required_gem_list.each do |g|
       params = ["install", g.name.to_s]
       params << "--version=#{g.version}" if g.version?
       params << "--source=#{g.source}" if g.source?
-      runner.run(params)
+      sh "gem #{params.join(" ")}"
     end
   end # install
   
-  private
-  task :setup do
-    gem 'mack'
-    require 'core_extensions/kernel'
-    require 'utils/gem_manager'
-    gem 'mack_ruby_core_extensions'
-    require 'mack_ruby_core_extensions'
-    require File.join(FileUtils.pwd, "config", "initializers", "gems")
-    require 'rubygems'
-    require 'rubygems/gem_runner'
-    Gem.manage_gems
-  end
-  
 end # gem

data/lib/{tasks → mack/tasks}/generator_tasks.rake

@@ -7,7 +7,7 @@ namespace :generator do
       g = g.constantize
       if g.respond_to?(:superclass) && g.superclass == Genosaurus
         list << g.name
-        list << "\n\t" << "rake generate:#{g.name.underscore}\n"
+        list << "\n\t" << "rake generate:#{g.name.underscore.gsub("_generator", '')}\n"
       end
     end
     list << "\n\n"

data/lib/{tasks → mack/tasks}/mack_tasks.rake

@@ -2,14 +2,13 @@ namespace :mack do
   
   desc "Loads the Mack environment. Default is development."
   task :environment do
-    require File.join(File.dirname(__FILE__), '..', 'mack')
+    require File.join(File.dirname(__FILE__), '..', "..", 'mack')
   end # environment
 
   desc "Loads an irb console allow you full access to the application w/o a browser."
   task :console do
     libs = []
     libs << "-r irb/completion"
-    # libs << "-r #{File.join(File.dirname(__FILE__), '..', 'mack')}"
     libs << "-r #{File.join(File.dirname(__FILE__), '..', 'initialization', 'console')}"
     exec "irb #{libs.join(" ")} --simple-prompt"
   end # console

data/lib/{tasks → mack/tasks}/rake_rules.rake

@@ -22,8 +22,4 @@ rule /^generate:/ do |t|
   Rake::Task["environment"].invoke
   klass = "#{klass.camelcase}Generator"
   gen = klass.constantize.run(ENV.to_hash)
-end
-
-rule /^test:rspec/ do |t|
-  raise "i'm running a test task!"
-end
+end

data/lib/{tasks → mack/tasks}/test_tasks.rake

@@ -2,7 +2,7 @@ require 'rake'
 require 'pathname'
 require 'spec'
 require 'spec/rake/spectask'
-
+require 'fileutils'
 namespace :test do
   
   task :setup do
@@ -25,14 +25,12 @@ namespace :test do
   task :stats do |t|
     ENV["MACK_ENV"] = "test"
     Rake::Task["mack:environment"].invoke
+    Rake::Task["test:setup"].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
-      unless @print
-        if line.match(/\d+ tests, \d+ assertions, \d+ failures, \d+ errors/)
-          @print = true
-        end
+      case line
+      when /^\+[\+\-]*\+$/, /^\|.*\|$/, /\d+\sLines\s+\d+\sLOC/
+        puts line
       end
     end
   end
@@ -41,6 +39,7 @@ namespace :test do
   task :coverage do |t|
     ENV["MACK_ENV"] = "test"
     Rake::Task["mack:environment"].invoke
+    Rake::Task["test:setup"].invoke
     `rcov test/**/*_#{app_config.mack.testing_framework == "rspec" ? "spec" : "test"}.rb -x Rakefile,config\/`
     `open coverage/index.html`
   end
@@ -55,7 +54,18 @@ namespace :test do
   
 end
 
+task :default do
+  require 'application_configuration'
+  app_config.load_file(File.join(FileUtils.pwd, "config", "app_config", "default.yml"))
+  app_config.load_file(File.join(FileUtils.pwd, "config", "app_config", "test.yml"))
+  tf = "rspec"
+  begin
+    tf = app_config.mack.testing_framework
+  rescue Exception => e
+  end
+  Rake::Task["test:setup"].invoke
+  Rake::Task["test:#{tf}"].invoke
+end
 
-alias_task :default, ["test:setup", "test:rspec"]
 alias_task :stats, "test:stats"
 alias_task :coverage, "test:coverage"