mack 0.8.0.101 → 0.8.1

data/lib/mack/routing/route_map.rb

@@ -47,7 +47,7 @@ module Mack
         routes = @_route_map[verb]
         routes.each do |route|
           if route.options[:host]
-            next unless route.options[:host].downcase == host
+            next unless !host.nil? && host.match(route.regex_patterns[:host])
           end
           if route.options[:scheme]
             next unless route.options[:scheme].downcase == scheme
@@ -56,7 +56,7 @@ module Mack
             next unless route.options[:port].to_i == port.to_i
           end
           if route.match?(path)
-            ret_val = route.options_with_parameters(path)
+            ret_val = route.options_with_parameters(path, host)
             return ret_val
           end
         end
@@ -93,6 +93,7 @@ module Mack
       #   "/:controller/:action"
       # These get created for each of the 4 HTTP verbs.
       def defaults
+        @_default_routes = []
         [:get, :post, :put, :delete].each do |verb|
           @_default_routes << RouteObject.new("/:controller/:action/:id", :method => verb)
           @_default_routes << RouteObject.new("/:controller/:action", :method => verb)
@@ -104,31 +105,32 @@ module Mack
       end
       
       # Sets up mappings and named routes for a resource.
-      def resource(controller, &block)
+      def resource(controller, options = {}, &block)
         # yield up to add other resources:
         if block_given?
-          proxy = ResourceProxy.new(controller)
+          proxy = ResourceProxy.new(controller, [controller.to_sym])
           yield proxy
           proxy.routes.each do |route|
-            connect_with_name("#{controller}_#{route[:name]}", route[:path], route[:options])
+            connect_with_name("#{controller}_#{route[:name]}", route[:path], options.merge(route[:options]))
           end
         end
         # connect the default resources:
-        connect_with_name("#{controller}_index", "/#{controller}", {:controller => controller, :action => :index, :method => :get})
-        connect_with_name("#{controller}_create", "/#{controller}", {:controller => controller, :action => :create, :method => :post})
-        connect_with_name("#{controller}_new", "/#{controller}/new", {:controller => controller, :action => :new, :method => :get})
-        connect_with_name("#{controller}_show", "/#{controller}/:id", {:controller => controller, :action => :show, :method => :get})
-        connect_with_name("#{controller}_edit", "/#{controller}/:id/edit", {:controller => controller, :action => :edit, :method => :get})
-        connect_with_name("#{controller}_update", "/#{controller}/:id", {:controller => controller, :action => :update, :method => :put})
-        connect_with_name("#{controller}_delete", "/#{controller}/:id", {:controller => controller, :action => :delete, :method => :delete})
+        build_resource_routes(controller, controller, controller, options)
       end
       
       def inspect # :nodoc:
         @_route_map.inspect
       end
       
-      private
-      def connect_with_name(name, path, options = {}, &block)
+      def routes_list # :nodoc:
+        @_route_map
+      end
+      
+      def default_routes_list # :nodoc:
+        @_default_routes || []
+      end
+      
+      def connect_with_name(name, path, options = {}, &block) # :nodoc:
         n_route = name.methodize
         route = connect(path, {:action => n_route.to_sym}.merge(options), &block)
         
@@ -145,9 +147,20 @@ module Mack
             options = {:host => @request.host, :scheme => @request.scheme, :port => @request.port}.merge(options)
           end
           self.send("#{n_route}_url", options)
-        end
+        end        
       end
       
+      def build_resource_routes(method_base, path_base, controller, options) # :nodoc:
+        connect_with_name("#{method_base}_index", "/#{path_base}", {:controller => controller, :action => :index, :method => :get}.merge(options))
+        connect_with_name("#{method_base}_create", "/#{path_base}", {:controller => controller, :action => :create, :method => :post}.merge(options))
+        connect_with_name("#{method_base}_new", "/#{path_base}/new", {:controller => controller, :action => :new, :method => :get}.merge(options))
+        connect_with_name("#{method_base}_show", "/#{path_base}/:id", {:controller => controller, :action => :show, :method => :get}.merge(options))
+        connect_with_name("#{method_base}_edit", "/#{path_base}/:id/edit", {:controller => controller, :action => :edit, :method => :get}.merge(options))
+        connect_with_name("#{method_base}_update", "/#{path_base}/:id", {:controller => controller, :action => :update, :method => :put}.merge(options))
+        connect_with_name("#{method_base}_delete", "/#{path_base}/:id", {:controller => controller, :action => :delete, :method => :delete}.merge(options))
+      end
+      
+      private
       def handle_options(opts, &block)
         opts = {:method => :get}.merge(opts.symbolize_keys)
         opts[:runner_block] = block if block_given?

data/lib/mack/routing/route_object.rb

@@ -5,15 +5,21 @@ module Mack
     class RouteObject # :nodoc:
       attr_accessor :options
       attr_accessor :path
-      attr_accessor :regex_pattern
-      attr_accessor :embedded_parameters
       attr_accessor :wildcard
+      attr_accessor :embedded_parameters
+      attr_accessor :regex_patterns
+      attr_accessor :insertion_order
       
       def initialize(path, options = {})
         self.path = path
         self.options = {:action => :index}.merge(options)
-        self.embedded_parameters = []
-        build_regex_pattern
+        # self.embedded_parameters = []
+        # self.host_embedded_parameters = []
+        self.regex_patterns = {}
+        self.embedded_parameters = {:uri => [], :host => []}
+        build_regex_patterns
+        
+        self.insertion_order = Mack::Routes::RouteObject.next_insertion_index
       end
       
       def ==(other)
@@ -21,7 +27,7 @@ module Mack
       end
       
       def match?(url)
-        if url.downcase.match(self.regex_pattern)
+        if url.downcase.match(self.regex_patterns[:uri])
           if self.options[:format]
             format = (File.extname(url).blank? ? '.html' : File.extname(url))
             format = format[1..format.length]
@@ -32,21 +38,18 @@ module Mack
         return false
       end
       
-      def options_with_parameters(url)
+      def options_with_parameters(url, host = nil)
         format = (File.extname(url).blank? ? '.html' : File.extname(url))
         format = format[1..format.length]
         opts = self.options.merge(:format => format)
         url = url.gsub(/\.#{format}$/, '')
-        if self.embedded_parameters.any?
-          url.split('/').each_with_index do |seg, i|
-            ep = self.embedded_parameters[i]
-            unless ep.nil?
-              opts[ep.to_sym] = seg
-            end
-          end
+        opts.merge!(get_embedded_parameters(:uri, url, '/'))
+        unless host.nil?
+          opts.merge!(get_embedded_parameters(:host, host, '.'))
+          opts.merge!(:host => host) if self.options[:host]
         end
         if self.wildcard
-          caps = url.match(self.regex_pattern).captures
+          caps = url.match(self.regex_patterns[:uri]).captures
           if caps
             opts[self.wildcard.to_sym] = caps.first.split('/')
           end
@@ -55,18 +58,48 @@ module Mack
         opts
       end
       
+      def <=>(other)
+        self.insertion_order <=> other.insertion_order
+      end
+      
       private
-      def build_regex_pattern
-        if self.path.is_a?(Regexp)
-          self.regex_pattern = self.path
+      
+      def self.next_insertion_index
+        (@__next_insertion_index ||= 0)
+        @__next_insertion_index += 1
+      end
+      
+      def get_embedded_parameters(name, path, splitter = '/')
+        vals = {}
+        if self.embedded_parameters[name].any? && !path.nil?
+          path.split(splitter).each_with_index do |seg, i|
+            ep = self.embedded_parameters[name][i]
+            unless ep.nil?
+              vals[ep.to_sym] = seg
+            end
+          end
+        end
+        vals
+      end
+      
+      def build_regex_patterns
+        {:uri => {:path => self.path, :splitter => '/', :emb_pat => ':'}, :host => {:path => self.options[:host], :splitter => '.', :emb_pat => ':'}}.each do |k, v|
+          build_regex_pattern(k, v[:path], v[:splitter], v[:emb_pat])
+        end
+      end
+      
+      def build_regex_pattern(name, path, splitter = '/', emb_pat = ':')
+        return if path.nil?
+        if path.is_a?(Regexp)
+          self.regex_patterns[name] = self.path
         elsif self.path.is_a?(String)
           reg = []
-          if self.path == '/'
-            self.regex_pattern = /^\/$/
+          if path == '/'
+            self.regex_patterns[name] = /^\/$/
           else
-            self.path.split('/').each_with_index do |seg, i|
-              if seg.match(/^:/)
-                self.embedded_parameters[i] = seg.gsub(':', '')
+            path.split(splitter).each_with_index do |seg, i|
+              if seg.match(/^#{emb_pat}/)
+                self.embedded_parameters[name][i] = seg.gsub(emb_pat, '')
                 reg << '[^/]+'
               elsif seg.match(/^\*/)
                 self.wildcard = seg.gsub('*', '')
@@ -75,10 +108,10 @@ module Mack
                 reg << seg.downcase
               end
             end
-            self.regex_pattern = /^#{reg.join('/') + '(\..+$|$)'}/
+            self.regex_patterns[name] = /^#{reg.join(splitter) + '(\..+$|$)'}/
           end
         else
-          raise ArgumentError.new("'#{self.path}' is a #{self.path.class} and it should be either a String or Regexp!")
+          raise ArgumentError.new("'#{path}' is a #{path.class} and it should be either a String or Regexp!")
         end
       end
       

data/lib/mack/routing/urls.rb

@@ -21,7 +21,17 @@ module Mack
         unused_params = []
         format = nil
         host_options = {:host => options[:host], :port => options[:port], :scheme => options[:scheme]}
-        options - [:host, :port, :scheme]
+        options - [:host, :port, :scheme, :runner_block]
+        if host_options[:host]
+          hu = host_options[:host].dup
+          options.each_pair do |k, v|
+            vp = Rack::Utils.escape(v.to_param)
+            unless hu.gsub!(":#{k}", vp).nil?
+              options - [k.to_sym]
+            end
+          end
+          host_options[:host] = hu
+        end
         options.each_pair do |k, v|
           unless k.to_sym == :format
             if u.match(/\*#{k}/)
@@ -89,7 +99,7 @@ module Mack
         else
           ":#{port}"
         end
-        return "#{scheme.downcase}://#{host.downcase}#{port}"
+        return "#{(scheme || 'http').downcase}://#{host.downcase}#{port}"
       end
       
     end # Urls

data/lib/mack/runner.rb

@@ -1,159 +1,11 @@
 require File.join(File.dirname(__FILE__), 'routing', 'urls')
+require File.join(File.dirname(__FILE__), 'application')
 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:
-    attr_reader :original_controller
-    attr_reader :original_action
-    
-    # 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.retrieve(self.request)
-          if route[:redirect_to]
-            # because the route is specified to be a redirect, let's do that:
-            redirect_to(route)
-          else
-            # set these in case we need them for handling errors:
-            @original_controller = route[:controller]
-            @original_action = route[:action]
-            run_controller(route)
-          end
-          # return teardown
-        rescue Exception => e
-          # 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 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
-      # Capture all the Exceptions for this call:
-      rescue Exception => 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)
-      runner_block = route[:runner_block]
-      route - :runner_block
-      
-      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?
+  class Runner # :nodoc:
 
-        self.response.controller = c
-        return self.response.write(c.run)
-      end
-    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)
-      # we can't find a route for this, so let's try and see if it's in the public directory:
-      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
-    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
-    
-    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)
+    def call(env) # :nodoc:
+      Mack::Application.new.call(env)
     end
     
-  end
-end
+  end # Runner
+end # Mack

data/lib/mack/sessions/cookie_session_store.rb

@@ -22,7 +22,7 @@ module Mack
             return sess
           rescue Exception => e
             # The cookie was bad, delete it and start a new session.
-            c.delete(id)
+            expire(id, request, response, cookies)
             return nil
           end
         end
@@ -35,6 +35,7 @@ module Mack
         # Deletes the cookie.
         def expire(id, request, response, cookies)
           cookies.delete(id)
+          response.delete_cookie(id)
         end
       
       end

data/lib/mack/tasks/mack_dump_tasks.rake

@@ -9,35 +9,79 @@ namespace :mack do
     
     desc "Show all the routes available"
     task :routes => :environment do
+      spacer
+
       include Mack::Routes::Urls
-      puts ""
-      puts "Routes:"
       
+      # Get all the defined routes
       routes = Mack::Routes::RouteMap.instance.routes_list
-      routes.each do |r|
-        # pp r.inspect
-        pat = r.original_pattern.blank? ? '/' : r.original_pattern
-        pat << "(.:format)"
-        opts = r.options.dup
-        meth = opts[:method]
-        opts.delete(:method)
-        puts "#{pat.rjust(50)}\t#{meth.to_s.upcase}\t#{opts.inspect.ljust(0)}"
+      # save the error mappings for display later:
+      errors = routes.delete(:errors)
+      
+      # set up an [] to house our routes in their proper order:
+      urls = []
+      # :get, :post, :put, :delete
+      routes.each do |section|
+        section[1].each do |r|
+          # get each route
+          urls << r
+        end
+      end
+      
+      # Add the default routes to the list:
+      Mack::Routes::RouteMap.instance.default_routes_list.each do |r|
+        urls << r
+      end
+
+      unless urls.empty?
+        section_header "Routes"
+        # Sort the urls based on when they were inserted :
+        urls.sort.each do |r|
+          r.options.delete(:runner_block)
+          print_nice(r.path + "(.:format)", r.options.delete(:method).to_s.upcase, r.options.inspect)
+        end
+        spacer
+      end
+      
+      unless errors.empty?
+        section_header "Error Mappings"
+        errors.each do |k, v|
+          print_nice(k, '', v.inspect)
+        end
+        spacer
       end
-      puts ""
-      puts "-" * 125
-      puts "Route helper methods:"
       
       url_methods = Mack::Routes::Urls.protected_instance_methods.collect {|x| x if x.match(/_url$/)}.compact
-      url_methods.sort.each do |meth|
-        unless meth.match(/(full|droute)_url$/)
-          puts "#{meth.rjust(50)}\t#{self.send(meth)}"
+      unless url_methods.empty?
+        section_header 'Route Helper Methods'
+        
+        @request = Mack::Request.new(Rack::MockRequest.env_for("http://www.example.com"))
+        url_methods.sort.each do |meth|
+          unless meth.match(/(full|distributed)_url$/)
+            print_nice(meth, '', self.send(meth))
+          end
         end
+        spacer
       end
-      puts ""
+      
     end # routes
+    
+    private
+    def spacer
+      puts ''
+      puts '-' * 125
+    end
+    
+    def print_nice(a, b, c)
+      puts "#{a.to_s.rjust(60)}\t#{b.to_s}\t#{c.to_s.ljust(0)}"
+    end
+    
+    def section_header(name)
+      puts "\n#{name}:"
+    end
 
   end # dump
 
 end # mack
 
-alias_task :routes, "mack:dump:routes"  
+alias_task :routes, "mack:dump:routes"