mack 0.0.3

data/mack_tasks.rb

@@ -0,0 +1,16 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+# Requires all rake tasks that ship with the Mack framework.
+[File.join(File.dirname(__FILE__)), File.join(FileUtils.pwd, "lib")].each do |dir|
+  begin
+    require File.join(dir, "tasks", "rake_helpers.rb")
+  rescue Exception => e
+  end
+  files = Dir.glob(File.join(dir, "tasks", "*.rake"))
+  files.each do |f|
+    unless f == __FILE__
+      load f
+    end
+  end
+end

data/routing/route_map.rb

@@ -0,0 +1,268 @@
+require 'singleton'
+module Mack
+  
+  module Routes
+    
+    # This method yields up Mack::Routes::RouteMap and allows for the creation of routes in the system.
+    # 
+    # 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::ViewBinder, Test::Unit::TestCase)
+      # 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.
+    #
+    # === 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/update # => {:controller => 'users', :action => :update, :method => :post} 
+    #     #                      # => 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.
+    class RouteMap
+      include Singleton
+      
+      def initialize # :nodoc:
+        @routes_list = []
+      end
+      
+      # Creates 'Rails' style default mappings:
+      #   "/:controller/:action/:id"
+      #   "/:controller/:action"
+      # These get created for each of the 4 HTTP verbs.
+      def defaults
+        [:get, :post, :put, :delete].each do |verb|
+          connect("/:controller/:action/:id", :method => verb)
+          connect("/:controller/:action", :method => verb)
+        end
+      end
+      
+      # Connects a url pattern to a controller, an action, and an HTTP verb.
+      def connect(pattern, options = {})
+        # set the default options:
+        options = {:action => :index, :method => :get}.merge(options)
+        meth = options[:method].to_sym
+        # if the pattern doesn't start with /, then add it.
+        pattern = "/" << pattern unless pattern.match(/^\//)
+        pt = pattern.downcase
+        route = Route.new(pt, regex_from_pattern(pt), meth, options)
+        routes_list << route
+        return route
+      end
+      
+      # 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})
+        connect_with_named_route("#{controller}_show", "/#{controller}/:id", {:controller => controller, :action => :show, :method => :get})
+        connect_with_named_route("#{controller}_edit", "/#{controller}/:id/edit", {:controller => controller, :action => :edit, :method => :get})
+        connect_with_named_route("#{controller}_update", "/#{controller}/:id/update", {:controller => controller, :action => :update, :method => :post})
+        connect_with_named_route("#{controller}_delete", "/#{controller}/:id", {:controller => controller, :action => :delete, :method => :delete})
+      end
+      
+      def method_missing(sym, *args) # :nodoc:
+        connect_with_named_route(sym, args.first, args.last)
+      end
+      
+      # Pass in a request 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 get_route_from_request(req)
+        pattern = req.path_info.downcase
+        unless pattern == "/"
+          pattern.chop! if pattern.match(/\/$/)
+        end
+        meth = (req.params("_method") || req.request_method.downcase).to_sym
+        begin
+          routes_list.each do |route|
+            if pattern.match(route.regex_pattern) && route.method == meth
+              r = route
+              opts = r.options_with_embedded_parameters(pattern)
+              req.merge_params(opts)
+              return opts
+            end
+          end
+        rescue Exception => e
+          raise e
+        end
+        # Can't find the route!
+        raise Mack::Errors::UndefinedRoute.new(req)
+      end # get
+      
+      private
+      attr_reader :routes_list # :nodoc:
+      
+      def connect_with_named_route(n_route, pattern, options = {})
+        route = connect(pattern, options)
+        Mack::Routes::Urls.class_eval %{
+            def #{n_route}_url(options = {})
+              url_for_pattern("#{route.original_pattern}", options)
+            end
+            
+            def #{n_route}_full_url(options = {})
+              u = #{n_route}_url(options)
+              "\#{@request.full_host}\#{u}"
+            end
+          }
+      end
+      
+      def regex_from_pattern(pattern)
+        pattern.chop! if pattern.match(/\/$/)
+        segs = []
+        sections = pattern.split("/")
+        sections.each_with_index do |sec, ind|
+          if sec.match(/\A:/)
+            segs << "[^/]+"
+          else
+            segs << sec
+          end
+        end
+        s = segs.join("/")
+        s = "/" if s.blank?
+        rx = /^#{s}$/
+        rx
+      end # regex_from_pattern
+      
+      class Route # :nodoc:
+        attr_accessor :regex_pattern
+        attr_accessor :method
+        attr_accessor :original_pattern
+        attr_accessor :options
+        attr_accessor :embedded_parameters
+        
+        def initialize(original_pattern, regex_pattern, method, options)
+          self.original_pattern = original_pattern
+          self.regex_pattern = regex_pattern
+          self.method = method
+          self.options = options
+          self.embedded_parameters = []
+          # find out where the embedded_parameters are:
+          original_pattern.split("/").each_with_index do |seg, ind|
+            if seg.match(/^:/)
+              self.embedded_parameters[ind] = seg[1..seg.length].to_sym
+            end
+          end
+        end
+        
+        def options_with_embedded_parameters(uri)
+          opts = self.options
+          split_uri = uri.split("/")
+          self.embedded_parameters.each_with_index do |val, ind|
+            unless val.nil?
+              opts[val] = split_uri[ind]
+            end
+          end
+          opts
+        end
+        
+      end # Route
+      
+    end # RouteMap
+
+  end # Routes
+  
+end # Mack

data/routing/urls.rb

@@ -0,0 +1,54 @@
+module Mack
+  module Routes
+    # This module is the repository for named_routes. See Mack::Routes::RouteMap for more information.
+    module Urls
+    
+      # Takes a url pattern and merges it with the options to hopefully produce a well formed url.
+      # Query string parameters will get escaped.
+      # 
+      # Example:
+      #   url_for_pattern("/:controller/:action/:id", {:controller => :blog, :action => :show, :id => 1})
+      #     # => "/blog/show/1
+      #   url_for_pattern("/:controller/:action/:id", {:controller => :blog, :action => :show})
+      #     # => "/blog/show/:id"
+      #   url_for_pattern("/blog/:id", {:id => 1})
+      #     # => "/blog/1
+      #   url_for_pattern("/blog/:id", {:id => 1, :n_id => 2})
+      #     # => "/blog/1?n_id=2
+      def url_for_pattern(url, options = {})
+        u = url.dup
+        unused_params = []
+        options.each_pair do |k, v|
+          vp = Rack::Utils.escape(v.to_param)
+          if u.gsub!(":#{k}", vp).nil?
+            unused_params << "#{Rack::Utils.escape(k)}=#{vp}"
+          end
+        end
+        unless unused_params.empty?
+          u << "?" << unused_params.sort.join("&")
+        end
+        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)
+        %{
+          <!DOCTYPE HTML PUBLIC 
+              "-//IETF//DTD HTML 2.0//EN"> 
+          <html>
+            <head> 
+              <title>#{status} Found</title> 
+            </head>
+            <body> 
+              <h1>Found</h1> 
+               <p>The document has moved <a href="#{new_path}">here</a>.</p> 
+            </body>
+          </html>
+        }
+      end
+    
+    end # Urls
+  end # Routes
+end # Mack

data/sea_level/controller_base.rb

@@ -0,0 +1,293 @@
+require 'erb'
+module Mack
+  module Controller # :nodoc:
+    # All controllers in a Mack application have to extend this class. I'll be honest, if they don't extend this class
+    # then, well, things just won't work very well!
+    # 
+    # Example:
+    #   class MyAwesomeController < Mack::Controller::Base
+    #     def index
+    #       render(:text => "Hello World!")
+    #     end
+    #   end
+    class Base
+      
+      # See Mack::Request for more information.
+      attr_reader :request
+      # See Mack::Response for more information.
+      attr_reader :response
+      # The 'underscore' version of the controller requested. Example: 'my_awesome_controller'
+      attr_reader :controller_name
+      # The name of the action being requested.
+      attr_reader :action_name
+      # See Mack::CookieJar for more information.
+      attr_reader :cookies
+
+      def initialize(request, response, cookies)
+        @request = request
+        @response = response
+        @render_options = {}
+        @render_performed = false
+        @controller_name = params(:controller)
+        @action_name = params(:action)
+        @cookies = cookies
+      end
+      
+      # Gives access to all the parameters for this request.
+      def params(key)
+        self.request.params(key)
+      end
+      
+      # Gives access to the session. See Mack::Session for more information.
+      def session
+        self.request.session
+      end
+      
+      # This does the heavy lifting for controllers. It calls the action, and then completes the rendering
+      # of the action to a String to send back to Rack.
+      def run
+        run_filters(:before)
+        # check to see if this controller responds to this action.
+        # only run public methods!
+        if self.public_methods.include?(self.action_name)
+          # call the action and capture the results to a variable.
+          @result_of_action_called = self.send(self.action_name)
+        else
+          # there is no action on this controller, so call the render method
+          # which will check the view directory and run action.html.erb if it exists.
+          render(:action => self.action_name)
+        end
+        run_filters(:after)
+        # do the work of rendering.
+        @final_rendered_action = complete_layout_render(complete_action_render)
+        run_filters(:after_render)
+        @final_rendered_action
+      end
+      
+      # This method can be called from within an action. This 'registers' the render that you
+      # would like to happen once the action is completed.
+      # 
+      # It's important to note that calling render in an action does NOT end the processing of
+      # the action. The action will continue to process unless you explicity put 'return' before the
+      # render call.
+      # 
+      # If you call render twice in an action then a Mack::Errors::DoubleRender error will be thrown.
+      # 
+      # An implicit render will happen if one is not specified in the action.
+      # 
+      # Only :action and :text will get layouts wrapped around them.
+      # 
+      # Examples:
+      #   class MyAwesomeController < Mack::Controller::Base
+      #     # This will render the text 'Hello World!' to the screen.
+      #     def index
+      #       render(:text => "Hello World!")
+      #     end
+      # 
+      #     # This will render MACK_ROOT/views/my_awesome_controller/foo.html.erb
+      #     def show
+      #       render(:action => :foo)
+      #     end
+      # 
+      #     # This will raise a Mack::Errors::DoubleRender error.
+      #     def edit
+      #       render(:text => "Hello World!")
+      #       render(:action => :foo)
+      #     end
+      # 
+      #     # This will render MACK_ROOT/views/my_awesome_controller/delete.html.erb
+      #     def delete
+      #     end
+      # 
+      #     # This will render the text 'Hello World!' to the screen. Assuming that
+      #     # there is no file: MACK_ROOT/views/my_awesome_controller/update.html.erb
+      #     # The reason for this is if the view for the action doesn't exist, and the
+      #     # last thing returned from the action is a String, that string will be returned.
+      #     def update
+      #       "Hello World!"
+      #     end
+      # 
+      #     # This will raise a Mack::Errors::InvalidRenderType error. Assuming that
+      #     # there is no file: MACK_ROOT/views/my_awesome_controller/create.html.erb
+      #     def create
+      #       @user = User.find(1)
+      #     end
+      # 
+      #     # This will raise a Errno::ENOENT error. Assuming that
+      #     # there is no file: MACK_ROOT/views/my_awesome_controller/bar.html.erb
+      #     def bar
+      #       render(:action => "bar")
+      #     end
+      #     
+      #     # This will render a file from the public directory. Files served from the
+      #     # public directory do NOT get layouts. The default file extension for files
+      #     # served from the public directory is .html. This can be overridden with the
+      #     # :ext => ".<ext>" option.
+      #     def show_public_file
+      #       render(:public => "my/files/foo")
+      #     end
+      # 
+      #     # This will render a file from the public directory. Files served from the
+      #     # public directory do NOT get layouts. The default file extension for files
+      #     # served from the public directory is .html. This can be overridden with the
+      #     # :ext => ".<ext>" option. 
+      #     def show_public_xml_file
+      #       render(:public => "my/files/foo", :ext => ".xml")
+      #     end
+      # 
+      #     # This will render a partial. In this case it will look for:
+      #     # MACK_ROOT/views/my_awesome_controller/_latest_news.html.erb
+      #     # Partials do NOT get wrapped in layouts.
+      #     def latest_news
+      #       render(:partial => :latest_news)
+      #     end
+      # 
+      #     # This will render a partial. In this case it will look for:
+      #     # MACK_ROOT/views/some_other/_old_news.html.erb
+      #     # Partials do NOT get wrapped in layouts.
+      #     def latest_news
+      #       render(:partial => "some_other/old_news")
+      #     end
+      #   end
+      def render(options = {:action => self.action_name})
+        raise Mack::Errors::DoubleRender.new if render_performed?
+        unless options[:action] || options[:text]
+          options = {:layout => false}.merge(options)
+        end
+        @render_options = options
+        @render_performed = true
+      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(url, status = 302)
+        response.status = status
+        response[:location] = url
+        render(:text => redirect_html(request.path_info, url, status))
+      end
+      
+      # Returns true/false depending on whether the render action has been called yet.
+      def render_performed?
+        @render_performed
+      end
+      
+      # Gives access to the MACK_DEFAULT_LOGGER.
+      def logger
+        MACK_DEFAULT_LOGGER
+      end
+      
+      private
+      
+      def run_filters(type)
+        filters = self.class.controller_filters[type]
+        return true if filters.empty?
+        filters.each do |filter|
+          if filter.run?(self.action_name.to_sym)
+            r = self.send(filter.filter_method)
+            raise Mack::Errors::FilterChainHalted.new(filter.filter_method) unless r
+          end
+        end
+      end
+      
+      def complete_layout_render(action_content)
+        @content_for_layout = action_content
+        # if @render_options[:action] || @render_options[:text]
+          # only action and text should get a layout.
+          # if a layout is specified, use that:
+          # i use has_key? here because we want people
+          # to be able to override layout with nil/false.
+          if @render_options.has_key?(:layout)
+            if @render_options[:layout]
+              return Mack::ViewBinder.new(self).render(@render_options.merge({:action => "layouts/#{@render_options[:layout]}"}))
+            else
+              # someone has specified NO layout via nil/false
+              return @content_for_layout
+            end
+          else layout
+            # use the layout specified by the layout method
+            return Mack::ViewBinder.new(self).render(@render_options.merge({:action => "layouts/#{layout}"}))
+          end
+        # end
+        @content_for_layout
+      end
+
+      def complete_action_render
+        if render_performed?
+          return Mack::ViewBinder.new(self, @render_options).render(@render_options)
+        else
+          begin
+            # try action.html.erb
+            return Mack::ViewBinder.new(self).render({:action => self.action_name})
+          rescue Exception => e
+            if @result_of_action_called.is_a?(String)
+              @render_options[:text] = @result_of_action_called
+              return Mack::ViewBinder.new(self).render(@render_options)
+            end
+            raise e
+          end
+        end
+      end # complete_action_render
+      
+      def layout
+        :application
+      end
+      
+      public
+      class << self
+        
+        def before_filter(meth, options = {})
+          add_filter(:before, meth, options)
+        end
+        
+        def after_filter(meth, options = {})
+          add_filter(:after, meth, options)
+        end
+        
+        def after_render_filter(meth, options = {})
+          add_filter(:after_render, meth, options)
+        end
+        
+        def add_filter(type, meth, options)
+          controller_filters[type.to_sym] << Mack::Controller::Filter.new(meth, options)
+        end
+        
+        def controller_filters
+          @controller_filters = {:before => [], :after => [], :after_render => []} unless @controller_filters
+          @controller_filters
+        end
+        
+        # Sets a layout to be used by a particular controller.
+        # 
+        # Example:
+        #   class MyAwesomeController < Mack::Controller::Base
+        #     # Sets all actions to use: "#{MACK_ROOT}/app/views/layouts/dark.html.erb" as they're layout.
+        #     layout :dark
+        # 
+        #     def index
+        #       # Sets this action to use: "#{MACK_ROOT}/app/views/layouts/bright.html.erb" as it's layout.
+        #       render(:text => "Welcome...", :layout => :bright)
+        #     end
+        # 
+        #     def index
+        #       # This will no use a layout.
+        #       render(:text => "Welcome...", :layout => false)
+        #     end
+        #   end
+        # 
+        # The default layout is "#{MACK_ROOT}/app/views/layouts/application.html.erb".
+        # 
+        # If a layout is specified, and it doesn't exist a Mack::Errors::UnknownLayout error will be raised.
+        def layout(lay)
+          self.class_eval do
+            define_method(:layout) do
+              lay
+            end
+          end
+        end # layout
+        
+      end # class << self
+      
+    end # Base
+  end # Controller
+end # Mack