mack 0.7.1.1 → 0.8.0

data/lib/mack/routing/routes.rb

@@ -0,0 +1,169 @@
+module Mack
+  # Routes are the back bone of the Mack framework. They are used to map incoming urls to controllers.
+  #
+  # === Defining Routes:
+  # Example:
+  #   Mack::Routes.build do |r|
+  #
+  #     # Connects "/" to the HomeController and the '/' action.
+  #     r.connect "/", :controller => :home
+  # 
+  #     # Connects "/foo", to the HomeController and the 'foo' action.
+  #     r.connect "/foo", :controller => :home, :action => :foo
+  #
+  #     # Connects "/blog" to the BlogController and the 'list' action.
+  #     r.connect "/blog", :controller => :blog, :action => :list
+  # 
+  #     # Connects "/blog/:id" to the BlogController and the 'index' action.
+  #     # It will also take the second half of the url and map it to a parameter called :id.
+  #     # Example:
+  #     #   '/blog/1' # => goes to the BlogController, 'index' action, and has an :id parameter == 1.
+  #     r.connect "/blog/:id", :controller => :blog, :action => :index
+  # 
+  #     # Connects "/blog/create" to the BlogController and the 'create' action.
+  #     # It also insists that the HTTP method be 'post'. If it's not 'post' it will not match this route.
+  #     r.connect "/blog/create", :controller => :blog, :action => :create, :method => :post
+  # 
+  #     # Connects "/comment/destroy/:id" to the CommentController and the 'destroy' action.
+  #     # It also insists that the HTTP method be 'delete'. If it's not 'delete' it will not match this route.
+  #     # It will also create an :id parameter.
+  #     r.connect "/comment/destroy/:id", :controller => :comment, :action => :destroy, :method => :delete
+  #
+  #     # This will create 'RESTful' routes. Unlike Rails, it doesn't generate a mixture of singular/plural
+  #     # routes. It uses whatever you pass in to it. This will also create named routes in Mack::Routes::Urls.
+  #     # Examples:
+  #     #   '/users' # => {:controller => 'users', :action => :index, :method => :get} 
+  #     #            # => users_index_url
+  #     #            # => users_index_full_url
+  #     #   '/users' # => {:controller => 'users', :action => :create, :method => :post} 
+  #     #            # => users_create_url
+  #     #            # => users_create_full_url
+  #     #   '/users/new' # => {:controller => 'users', :action => :new, :method => :get} 
+  #     #                # => users_new_url
+  #     #                # => users_new_full_url
+  #     #   '/users/:id' # => {:controller => 'users', :action => :show, :method => :get} 
+  #     #                # => users_show_url
+  #     #                # => users_show_full_url
+  #     #   '/users/:id/:edit # => {:controller => 'users', :action => :edit, :method => :get} 
+  #     #                     # => users_edit_url
+  #     #                     # => users_edit_full_url
+  #     #   '/users/:id # => {:controller => 'users', :action => :update, :method => :put} 
+  #     #                      # => users_update_url
+  #     #                      # => users_update_full_url
+  #     #   '/users/:id # => {:controller => 'users', :action => :delete, :method => :delete} 
+  #     #               # => users_delete_url
+  #     #               # => users_delete_full_url
+  #     r.resource :users
+  # 
+  #     # This will redirect '/old_users/show/:id' to '/users/:id' with a status of 302, 'Moved Temporarily'.
+  #     # Examples:
+  #     #   '/old_users/show/1' # => '/users/1' (status of 302)
+  #     #   '/old_users/show/1?foo=bar' # => '/users/1?foo=bar' (status of 302)
+  #     r.connect '/old_users/show/:id', :redirect_to => "/users/:id"
+  # 
+  #     # This will redirect '/old_blog' to '/blog' with a status of 301, 'Moved Permanently'.
+  #     # Examples:
+  #     #   '/old_blog' # => '/blog' (status of 301)
+  #     #   '/old_blog?foo=bar' # => '/blogfoo=bar' (status of 301)
+  #     r.connect '/old_blog', :redirect_to => "/blog", :status => 301
+  # 
+  #     # Connects "/comment/update/:id" to the CommentController and the 'update' action.
+  #     # It will also create an :id parameter.
+  #     # It will also create a named route in Mack::Routes::Urls called, 'c_u_url'.
+  #     # In a controller or a view this: c_u_url(:id => 1) would return '/comment/update/1'.
+  #     # It will also create a named route in Mack::Routes::Urls called, 'c_u_full_url'.
+  #     # In a controller or a view this: c_u_full_url(:id => 1) would return 'http://example.org/comment/update/1'.
+  #     r.c_u "/comment/update/:id", {:controller => :comment, :action => :update}
+  #
+  #     # This creates 'Rails' style routes.
+  #     # Any requests that come in that aren't found by explicit routes, will fall into these routes.
+  #     # '/:controller/:action'
+  #     # '/:controller/:action/:id'
+  #     #
+  #     # Example:
+  #     #   '/comment/show/1' # => Goes to CommentController, the 'show' action, with a parameter of 1.
+  #     r.defaults
+  #   
+  #   end
+  # 
+  # === Named Routes:
+  #   Mack::Routes.build do |r|
+  #     r.resource :users
+  #   end
+  # See above in 'Defining Routes' to see what fully gets created when you map a resource, but let's look
+  # at the named route stuff that gets generated. In particular let's look at one example:
+  #   '/users/:id' # => {:controller => 'users', :action => :show, :method => :get} 
+  #                # => users_show_url
+  #                # => users_show_full_url
+  # The following can be used in controllers, views, and tests:
+  #   users_show_url(:id => 1) # => '/users/1'
+  #   # The following can only be used when there is a @request (Mack::Request) instance variable around:
+  #   users_show_full_url(:id => 1) # => 'http://example.org/users/1' 
+  # 
+  #   Mack::Routes.build do |r|
+  #     r.hello_world "/", :controller => :home_page, :action => :hello
+  #   end
+  # This will give you the following two methods:
+  #   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.
+  module Routes
+    include Extlib::Hook
+    
+    class << self
+      
+      # This method yields up Mack::Routes::RouteMap and allows for the creation of routes in the system.
+      def build
+        yield Mack::Routes::RouteMap.instance
+        Mack::Routes::Urls.include_safely_into(Mack::Controller, 
+                                               Mack::Rendering::ViewTemplate, 
+                                               Test::Unit::TestCase)
+      end
+      
+      def any?
+        Mack::Routes::RouteMap.instance.any?
+      end
+      
+      def empty?
+        Mack::Routes::RouteMap.instance.empty?
+      end
+      
+      def reset!
+        Mack::Routes::RouteMap.instance.reset!
+      end
+      
+      # Pass in a request or a String and it will try and give you back a Hash representing the 
+      # options for that route. IE: controller, action, verb, etc...
+      # If there are embedded options they added to the Hash. These parameters are
+      # also added to the 'params' object in the request.
+      # If the route can not be found a Mack::Errors::UndefinedRoute exception is raised.
+      def retrieve(url_or_request, verb = :get)
+        Mack::Routes::RouteMap.instance.retrieve(url_or_request, verb)
+      end
+      
+      # Given an error class name it will return a routing options Hash, or nil, if one
+      # has not been mapped.
+      def retrieve_from_error(error)
+        Mack::Routes::RouteMap.instance.retrieve_from_error(error)
+      end
+      
+      def inspect # :nodoc:
+        Mack::Routes::RouteMap.instance.inspect
+      end
+      
+    end
+    
+  end # Routes
+end # Mack

data/lib/mack/routing/urls.rb

@@ -20,11 +20,20 @@ module Mack
         u = "/" if url.blank?
         unused_params = []
         format = nil
+        host_options = {:host => options[:host], :port => options[:port], :scheme => options[:scheme]}
+        options - [:host, :port, :scheme]
         options.each_pair do |k, v|
           unless k.to_sym == :format
-            vp = Rack::Utils.escape(v.to_param)
-            if u.gsub!(":#{k}", vp).nil?
-              unused_params << "#{Rack::Utils.escape(k)}=#{vp}"
+            if u.match(/\*#{k}/)
+              vp = [v].flatten.collect {|c| Rack::Utils.escape(c.to_param)}
+              if u.gsub!("*#{k}", File.join(vp)).nil?
+                unused_params << "#{Rack::Utils.escape(k)}=#{vp}"
+              end
+            else
+              vp = Rack::Utils.escape(v.to_param)
+              if u.gsub!(":#{k}", vp).nil?
+                unused_params << "#{Rack::Utils.escape(k)}=#{vp}"
+              end
             end
           else
             format = v
@@ -36,13 +45,14 @@ module Mack
         unless unused_params.empty?
           u << "?" << unused_params.sort.join("&")
         end
-        u
+        File.join(build_full_host_from_options(host_options), u)
+        # u
       end
     
       # Builds a simple HTML page to be rendered when a redirect occurs.
       # Hopefully no one sees the HTML, but in case the browser won't do the
       # redirect it's nice to let people know what's happening.
-      def redirect_html(original_path, new_path, status)
+      def redirect_html(original_path, new_path, status) # :nodoc:
         %{
           <!DOCTYPE HTML PUBLIC 
               "-//IETF//DTD HTML 2.0//EN"> 
@@ -58,6 +68,30 @@ module Mack
         }
       end
       
+      def self.create_method(sym, &block) # :nodoc:
+        define_method(sym, &block)
+      end
+      
+      private
+      def build_full_host_from_options(options = {})
+        scheme = options[:scheme]
+        host = options[:host]
+        port = options[:port]
+        return '' if host.blank? && scheme.blank? && port.nil?
+        if @request
+          scheme = @request.scheme if scheme.nil?
+          port = @request.port if port.nil?
+          host = @request.host if host.nil?
+        end
+        port = 80 if port.nil?
+        port = case port.to_i
+        when 80, 443
+        else
+          ":#{port}"
+        end
+        return "#{scheme.downcase}://#{host.downcase}#{port}"
+      end
+      
     end # Urls
   end # Routes
 end # Mack 

data/lib/mack/runner.rb

@@ -16,10 +16,11 @@ module Mack
     # 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)
+      env["rack.errors"] = StringIO.new # Send Rack errors nowhere fast!
       begin
         setup(env)
         begin
-          route = Mack::Routes::RouteMap.instance.get_route_from_request(self.request)
+          route = Mack::Routes.retrieve(self.request)
           if route[:redirect_to]
             # because the route is specified to be a redirect, let's do that:
             redirect_to(route)
@@ -29,48 +30,70 @@ module Mack
             @original_action = route[:action]
             run_controller(route)
           end
-        # rescue Mack::Errors::ResourceNotFound, Mack::Errors::UndefinedRoute => e
-        #   return try_to_find_resource(env, e)
+          # return teardown
         rescue Exception => e
-          route = Mack::Routes::RouteMap.instance.get_route_from_error(e.class)
-          self.request.all_params[:original_controller] = @original_controller
-          self.request.all_params[:original_action] = @original_action
+          # There was an exception, let's see if there's a handler for this error in routes:
+          route = Mack::Routes.retrieve_from_error(e.class)
           unless route.nil?
+            self.request.all_params[:original_controller] = @original_controller
+            self.request.all_params[:original_action] = @original_action
+            # There is a handler, let's try running that:
             run_controller(route, e)
           else
-            if e.class == Mack::Errors::ResourceNotFound || e.class == Mack::Errors::UndefinedRoute
+            # If we can't find the resource, or there's no route, let's check the public directory:
+            case e
+            when Mack::Errors::ResourceNotFound, Mack::Errors::UndefinedRoute
               return try_to_find_resource(env, e)
             else
+              # Re-raise the exception
               raise e
             end
           end
+          # return teardown
         end
-        teardown
+      # Capture all the Exceptions for this call:
       rescue Exception => e
-        Mack.logger.error(e)
-        raise e
+        Mack.logger.error e
+        case e
+        when Mack::Errors::ResourceNotFound, Mack::Errors::UndefinedRoute
+          handle_error(404, 'Page Not Found!', e)
+        # If it's any other type of exception render the 500.html page:
+        else
+          handle_error(500, 'Server Error!', e)
+        end
+        # return teardown
+      ensure
+        teardown
       end
+      return self.response.finish
     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)
+      runner_block = route[:runner_block]
+      route - :runner_block
       
-      c = cont.new
-      c.configure_controller(self.request, self.response, self.cookies)
-      c.caught_exception = e unless e.nil?
+      self.request.params = self.request.all_params.merge(route)
+      self.response.content_type = Mack::Utils::MimeTypes[self.request.params[:format]]
+      catch(:finished) do
+        if runner_block
+          runner_block.call(self.request, self.response, self.cookies)
+        end
+      
+        # 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
+      
+        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)
+        self.response.controller = c
+        return self.response.write(c.run)
+      end
     end
     
     # Setup the request, response, cookies, session, etc...
@@ -91,17 +114,16 @@ module Mack
       self.runner_helpers.reverse.each do |help|
         help.complete(self.request, self.response, self.cookies)
       end
-      self.response.finish
+      # 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?(Mack::Paths.public(env["PATH_INFO"]))
-        return Rack::File.new(Mack::Paths.public).call(env)
+      path = env["PATH_INFO"].dup
+      path << ".html" if File.extname(path).blank?
+      
+      if File.exists?(Mack::Paths.public(path))
+        return Rack::File.new(Mack::Paths.public).call(Rack::MockRequest.env_for(path))
       else
         raise exception
       end
@@ -122,5 +144,16 @@ module Mack
       self.response.write(redirect_html(self.request.path_info, url, status))
     end
     
+    private
+    def handle_error(status, body, e)
+      self.response.status = status
+      raise e if configatron.mack.show_exceptions
+      path = Mack::Paths.public("#{status}.html")
+      if File.exists?(path)
+        body = File.read(path)
+      end
+      self.response.write(body)
+    end
+    
   end
 end

data/lib/mack/runner_helpers/request_logger.rb

@@ -16,11 +16,11 @@ module Mack
         @end_time = Time.now
         @total_time = @end_time - @start_time
         @requests_per_second = (1 / @total_time).round
-        if app_config.log.detailed_requests
+        if configatron.mack.log.detailed_requests
           msg = "\n\t[#{request.params[:method].to_s.upcase}] '#{request.path_info}'\n"
-          msg << "\tSession ID: #{request.session.id}\n" if app_config.mack.use_sessions
+          msg << "\tSession ID: #{request.session.id}\n" if configatron.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}]")
+          msg << Mack::Utils::Ansi::Color.wrap(configatron.mack.log.colors.completed, "\tCompleted in #{@total_time} (#{@requests_per_second} reqs/sec) | #{response.status} (#{Mack::Utils::HttpStatusCodes.get(response.status)}) [#{request.full_host}]")
         else
           msg = "[#{request.request_method.upcase}] '#{request.path_info}' (#{total_time})"
         end

data/lib/mack/runner_helpers/session.rb

@@ -6,7 +6,7 @@ module Mack
       attr_accessor :sess_id
       
       def start(request, response, cookies)
-        if app_config.mack.use_sessions
+        if configatron.mack.use_sessions
           self.sess_id = retrieve_session_id(request, response, cookies)
           unless self.sess_id
             self.sess_id = create_new_session(request, response, cookies)
@@ -23,7 +23,7 @@ module Mack
       end
       
       def complete(request, response, cookies)
-        if app_config.mack.use_sessions
+        if configatron.mack.use_sessions
           unless response.redirection?
             request.session.delete(:tell)
           end
@@ -33,12 +33,12 @@ module Mack
       
       private
       def retrieve_session_id(request, response, cookies)
-        cookies[app_config.mack.session_id]
+        cookies[configatron.mack.session_id]
       end
       
       def create_new_session(request, response, cookies)
         id = String.randomize(40).downcase
-        cookies[app_config.mack.session_id] = {:value => id, :expires => nil}
+        cookies[configatron.mack.session_id] = {:value => id, :expires => nil}
         sess = Mack::Session.new(id)
         request.session = sess
         Mack::SessionStore.set(request.session.id, request, response, cookies)

data/lib/mack/sessions/cookie_session_store.rb

@@ -4,9 +4,9 @@ module Mack
     # Stores session information in the user's cookie.
     # The session information is encrypted using the mack-encryption library.
     # This is the default session store for Mack applications.
-    # To set the expiry time for this session store use the following app_config setting:
+    # To set the expiry time for this session store use the following configatron setting:
     #   cookie_session_store::expiry_time: <%= 4.hours %>
-    # It is recommend that you set the app_config setting 'default_secret_key' to
+    # It is recommend that you set the configatron setting 'default_secret_key' to
     # something, otherwise it will generate a random one each time you start your application,
     # which could make decrypting cookies a bit of a pain. :)
     class Cookie < Mack::SessionStore::Base
@@ -29,7 +29,7 @@ module Mack
         
         # Encrypts the session and places it into the cookie.
         def set(id, request, response, cookies)
-          cookies[id] = {:value => YAML.dump(request.session).encrypt, :expires => (Time.now + app_config.cookie_session_store.expiry_time)}
+          cookies[id] = {:value => YAML.dump(request.session).encrypt, :expires => (Time.now + configatron.mack.cookie_session_store.expiry_time)}
         end
         
         # Deletes the cookie.

data/lib/mack/sessions/session.rb

@@ -2,7 +2,7 @@ module Mack
   
   # A holder for the session information. This objects gets stored using the Cachetastic system.
   # For more information about how Cachetastic works see the RDoc for that gem.
-  # The session cookie name defaults to: _mack_session_id but can be changed using the application_configuration
+  # The session cookie name defaults to: _mack_session_id but can be changed using the configatron
   # system like such:
   #   mack::session_id: _my_cool_app_sess_id
   class Session

data/lib/mack/sessions/session_store_base.rb

@@ -5,7 +5,7 @@ module Mack
       
       def store # :nodoc:
         ivar_cache do
-          "Mack::SessionStore::#{app_config.mack.session_store.camelcase}".constantize
+          "Mack::SessionStore::#{configatron.mack.session_store.camelcase}".constantize
         end
       end
       

data/lib/mack/tasks/gem_tasks.rake

@@ -1,3 +1,4 @@
+
 namespace :gems do
   
   desc "lists all the gem required for this application."
@@ -17,4 +18,158 @@ namespace :gems do
     end
   end # install
   
-end # gem
+  task :freeze do
+    Mack::Utils::GemManager.instance.required_gem_list.each do |g|
+      version = g.version? ? g.version : '> 0.0.0'
+      ENV['gem_name'] = g.name.to_s
+      ENV['version'] = version
+      ENV['source'] = g.source? ? g.source : 'http://gems.rubyforge.org'
+      sh('rake gems:install_and_freeze')
+    end
+  end # freeze
+  
+  task :install_and_freeze do
+    require 'rubygems/gem_runner'
+    add_dependencies = ENV['INCLUDE_DEPENDENCIES'] || ENV['include_dependencies'] || false
+    add_dependencies = false if add_dependencies.to_s.downcase == 'false'
+    version = ENV['version'] || ENV['VERSION'] || ENV['ver'] || ENV['VER'] || '> 0.0.0'
+    source  = ENV['source']  || ENV['SOURCE'] || 'http://gems.rubyforge.org'
+    gem_name = ENV['gem_name']
+    
+    dep_msg = "and its dependencies" if add_dependencies
+    puts "\nTask: freezing #{gem_name} #{dep_msg} to #{local_gem_dir}."
+    puts "Phase 1: Collecting information..."
+    if add_dependencies
+      collect_dependencies(gem_name, version)
+    else
+      version = source_index.find_name(gem_name, version).last.version.to_s
+      processed_gems << LocalGem.new(gem_name, version)
+    end
+    puts "\nPhase 2: Checking installation states..."
+    check_installation(source)
+    puts "\nPhase 3: Freezing Gems and Specs..."
+    freeze_gems
+    puts "\nPhase 4: validating data..."
+    validate
+    puts "\nTotal of #{processed_gems.size} gems frozen to #{local_gem_dir}"
+  end # install_and_freeze
+end # gem
+
+private
+
+def local_gem_dir
+  dir = Mack::Paths.vendor('gems')
+  mkdir(dir) if !File.exists?(dir)
+  return dir
+end
+
+def processed_gems
+  @gem_list ||= []
+  return @gem_list
+end
+
+def source_index
+  @src_index ||= Gem::SourceIndex.from_installed_gems
+  return @src_index
+end
+
+def collect_dependencies(gem_name, version)
+  # normalize the version
+  version = source_index.find_name(gem_name, version).last.version.to_s
+  gem = LocalGem.new(gem_name, version)
+  
+  if !processed_gems.include?gem
+    processed_gems << gem
+    do_dependencies(gem_name, version) do |dep_gem|
+      collect_dependencies(dep_gem.name, dep_gem.version_requirements.to_s)
+    end
+  end
+end
+
+def validate
+  processed_gems.each do |gem|
+    file_name = File.join(local_gem_dir, gem.name + "-" + gem.version)
+    if !File.exists?file_name
+      puts "  ** Warning: #{gem.name} was skipped"
+    end
+  end
+end
+
+def check_installation(source = 'http://gems.rubyforge.org')
+  processed_gems.each do |gem|
+    res = Gem.cache.search(/^#{gem.name}$/i, gem.version)
+    if !res or res.empty?
+      msg "  ** #{gem.name} not installed.  Installing #{gem.name} - #{gem.version}"
+      params = ["install", gem.name]
+      params << "--version=#{gem.version}"
+      params << "--source=#{source}"
+      sh "sudo gem #{params.join(" ")}"
+    else
+      msg "  ** #{gem.name} has been installed."
+    end
+  end
+end
+
+def freeze_gems
+  processed_gems.each do |gem|
+    file_name = File.join(local_gem_dir, gem.name + "-" + gem.version)
+    if File.exists?file_name
+      msg "  ** #{gem.name} is already frozen, skipping it."
+    else
+      chdir(local_gem_dir) do
+        begin
+          Gem::GemRunner.new.run(["unpack", gem.name, "--version", gem.version])
+          spec = source_index.find_name(gem.name, gem.version).last
+          spec_file = File.join(file_name, "spec.yaml")
+          File.open(spec_file, "w") { |f| f.write(spec.to_yaml) }
+        rescue Exception => ex
+          puts ex
+        end        
+      end
+    end
+  end
+end
+
+def do_dependencies(gem_name, version = "> 0.0.0", &block)
+  raise "Block expected!" if !block_given?
+  source_indexes = Gem::SourceIndex.from_installed_gems
+  # get the last item in the 'found list'.  That's the latest version.  If user passed in specific version, then there's only 1 in the list
+  deps = source_indexes.find_name(gem_name, version).last.dependencies
+  msg "  ** Found #{deps.size} dependencies for #{gem_name}-#{version}"
+  deps.each do |dep_gem|
+    yield(dep_gem)
+  end  
+end
+
+def msg(msg)
+  verbose = ENV['VERBOSE'] || ENV['verbose'] || false
+  verbose = false if verbose.to_s.downcase == 'false'
+  puts msg if verbose
+  print "." if !verbose
+end
+
+class LocalGem
+  attr_accessor :name
+  attr_accessor :version
+  
+  def initialize(name, version)
+    self.name = name
+    self.version = version
+  end
+  
+  def to_s
+    "#{name}-#{version}"
+  end
+  
+  def ==(other)
+    other.to_s == self.to_s
+  end
+  
+  def eql?(other)
+    other.to_s == self.to_s
+  end
+  
+  def hash
+    self.to_s.hash
+  end
+end

data/lib/mack/tasks/mack_dump_tasks.rake

@@ -4,7 +4,7 @@ namespace :mack do
 
     desc "Dumps out the configuration for the specified environment."
     task :config => :environment do
-      pp Mack::Configuration.dump
+      puts Mack::Configuration.dump
     end # config
     
     desc "Show all the routes available"