mack 0.5.0 → 0.5.5

data/lib/rendering/type/xml.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), "..", "view_template")
+module Mack
+  module Rendering # :nodoc:
+    module Type # :nodoc:
+      # Used to render an XML template that's relative to a controller.
+      # 
+      # Example:
+      #   class UsersController < Mack::Controller::Base
+      #     # /users/:id
+      #     def show
+      #       @user = User.first(params(:id))
+      #     end
+      #     # /users
+      #     def index
+      #       @users = User.all
+      #       render(:xml, :list)
+      #     end
+      #   end
+      # When some calls /users/1.xml the file: app/views/users/show.xml.builder will be rendered.
+      # When some calls /users.xml the file: app/views/users/list.xml.builder will be rendered.
+      class Xml < Mack::Rendering::Type::FileBase
+        
+        # See Mack::Rendering::Type::FileBase render_file for more information.
+        def render
+          self.options[:format] = "xml"
+          self.controller.response["Content-Type"] = Mack::Utils::MimeTypes[self.options[:format]]
+          x_file = File.join(self.controller_view_path, "#{self.render_value}.#{self.options[:format]}")
+          render_file(x_file, :xml)
+        end
+        
+      end # Xml
+    end # Type
+  end # Rendering
+end # Mack

data/lib/rendering/view_template.rb

@@ -0,0 +1,168 @@
+module Mack
+  module Rendering # :nodoc:
+    # This class is used to do all the view level bindings.
+    # It allows for seperation between the Mack::Controller::Base and the view levels.
+    class ViewTemplate
+      
+      # Allows access to any options passed into the template.
+      attr_accessor :options
+      attr_accessor :render_type
+      attr_accessor :render_value
+      
+      def initialize(render_type, render_value, options = {})
+        self.render_type = render_type
+        self.render_value = render_value
+        self.options = options
+        @_yield_to_cache = {}
+      end
+      
+      # Allows access to the current Mack::Controller::Base object.
+      def controller
+        self.options[:controller]
+      end
+      
+      # Returns the Mack::Request associated with the current Mack::Controller::Base object.
+      def request
+        self.controller.request
+      end
+      
+      # Returns the Mack::Session associated with the current Mack::Request.
+      def session
+        self.request.session
+      end
+      
+      # Returns the Mack::CookieJar associated with the current Mack::Controller::Base object.
+      def cookies
+        self.controller.cookies
+      end
+      
+      # If a method can not be found then the :locals key of
+      # the options is used to find the variable.
+      def method_missing(sym, *args)
+        raise NoMethodError.new(sym.to_s) unless self.options[:locals]
+        self.options[:locals][sym]
+      end
+      
+      # Maps to the controller's param method. See also Mack::Controller::Base params.
+      def params(key)
+        self.controller.params(key)
+      end
+      
+      # Handles rendering calls both in the controller and in the view.
+      # For full details of render examples see Mack::Controller::Base render.
+      # Although the examples there are all in controllers, they idea is still
+      # the same for views.
+      # 
+      # Examples in the view:
+      #   <%= render(:text,  "Hello") %>
+      #   <%= render(:action, "show") %>
+      #   <%= render(:partial, :latest_news) %>
+      #   <%= render(:url, "http://www.mackframework.com") %>
+      def render(render_type, render_value, options = {})
+        options = self.options.merge({:layout => false}).merge(options)
+        Mack::Rendering::ViewTemplate.new(render_type, render_value, options).compile_and_render
+      end
+      
+      # Returns a string stored using content_for.
+      # 
+      # Example:
+      #   <% content_for(:hello, "Hello World") %>
+      #   <%= yield_to :hello %> # => "Hello World"
+      #   
+      #   <% content_for(:bye) do %>
+      #     Ah, it's so sad to say goodbye.
+      #   <% end %>
+      #   <%= yield_to :bye %> # => "Ah, it's so sad to say goodbye."
+      def yield_to(key)
+        @_yield_to_cache[key.to_sym]
+      end
+      
+      # Stores a string that can be retrieved using yield_to.
+      # 
+      # Example:
+      #   <% content_for(:hello, "Hello World") %>
+      #   <%= yield_to :hello %> # => "Hello World"
+      #   
+      #   <% content_for(:bye) do %>
+      #     Ah, it's so sad to say goodbye.
+      #   <% end %>
+      #   <%= yield_to :bye %> # => "Ah, it's so sad to say goodbye."
+      def content_for(key, value = nil, &block)
+        return @_yield_to_cache[key.to_sym] = value unless value.nil?
+        return @_yield_to_cache[key.to_sym] = @_render_type.capture(&block) if block_given?
+      end
+
+      # Transfers all the instance variables from the controller to the current instance of
+      # the view template. This call is cached, so it only happens once, regardless of the number
+      # of times it is called.
+      def compile
+        ivar_cache("compiled_template") do
+          self.options.symbolize_keys!
+          transfer_vars(self.controller)
+        end
+      end
+      
+      # Fully compiles and renders the view and, if applicable, it's layout.
+      def compile_and_render
+        self.compile
+        content_for(:view, render_view)
+        render_layout
+      end
+      
+      # Passes concatenation messages through to the Mack::Rendering::Type object.
+      # This should append the text, using the passed in binding, to the final output
+      # of the render.
+      def concat(txt, b)
+        @_render_type.concat(txt, b)
+      end
+      
+      # Primarily used by Mack::Rendering::Type::Url when dealing with 'local' urls.
+      # This returns an instance of the current application to run additional requests
+      # through.
+      def app_for_rendering
+        ivar_cache do
+          Mack::Utils::Server.build_app
+        end
+      end
+      
+      # Returns the binding of the current view template to be used with
+      # the engines to render.
+      def binder
+        binding
+      end
+      
+      private
+      
+      def render_layout
+        if @_render_type.allow_layout? && self.options[:layout]
+          return Mack::Rendering::Type::Layout.new(self).render
+        end
+        return yield_to(:view)
+      end
+      
+      def render_view
+        @_render_type = find_render_type(self.render_type).new(self)
+        @_render_type.render
+      end
+      
+      def find_file(*path)
+        f = File.join(path)
+        if File.exists?(f)
+          yield f
+        end
+      end
+  
+      # Transfer instance variables from the controller to the view.
+      def transfer_vars(x)
+        x.instance_variables.each do |v|
+          self.instance_variable_set(v, x.instance_variable_get(v))
+        end
+      end
+      
+      def find_render_type(e)
+        eval("Mack::Rendering::Type::#{e.to_s.camelcase}")
+      end
+      
+    end # ViewTemplate
+  end # Mack
+end # Mack

data/lib/routing/route_map.rb

@@ -9,7 +9,7 @@ module Mack
     def self.build
       yield Mack::Routes::RouteMap.instance
       Mack::Routes::Urls.include_safely_into(Mack::Controller::Base, 
-                                             Mack::ViewBinder, 
+                                             Mack::Rendering::ViewTemplate, 
                                              Test::Unit::TestCase, 
                                              Mack::Distributed::Routes::Urls)
       if app_config.mack.use_distributed_routes
@@ -134,6 +134,7 @@ module Mack
       
       def initialize # :nodoc:
         @routes_list = []
+        @default_routes_list = []
       end
       
       # Creates 'Rails' style default mappings:
@@ -141,21 +142,16 @@ module Mack
       #   "/:controller/:action"
       # These get created for each of the 4 HTTP verbs.
       def defaults
+        @default_routes_list = []
         [:get, :post, :put, :delete].each do |verb|
-          connect("/:controller/:action/:id", :method => verb)
-          connect("/:controller/:action", :method => verb)
+          @default_routes_list << build_route("/:controller/:action/:id", :method => verb)
+          @default_routes_list << build_route("/: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)
+        route = build_route(pattern, options)
         routes_list << route
         return route
       end
@@ -187,8 +183,11 @@ module Mack
           pattern.chop! if pattern.match(/\/$/)
         end
         meth = (req.params("_method") || req.request_method.downcase).to_sym
+        rt = routes_list.dup
+        rt << @default_routes_list.dup
+        rt.flatten!
         begin
-          routes_list.each do |route|
+          rt.each do |route|
             if pattern.match(route.regex_pattern) && route.method == meth
               r = route
               opts = r.options_with_embedded_parameters(pattern)
@@ -206,6 +205,16 @@ module Mack
       attr_reader :routes_list # :nodoc:
       
       private
+      def build_route(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.new(pt, regex_from_pattern(pt), meth, options)
+      end
+      
       def connect_with_named_route(n_route, pattern, options = {})
         n_route = n_route.methodize
         route = connect(pattern, options)

data/lib/runner.rb

@@ -0,0 +1,137 @@
+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 Mack::Routes::Urls
+    
+    attr_reader :response # :nodoc:
+    attr_reader :request # :nodoc:
+    attr_reader :cookies # :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)
+      # pp env
+      begin
+        setup(env) do
+          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
+              # 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(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)
+        raise e
+      end
+    end
+    
+    private
+    def log_request
+      s_time = Time.now
+      x = yield
+      e_time = Time.now
+      p_time = e_time - s_time
+      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 << "\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)
+      x
+    end
+    
+    # Setup the request, response, cookies, session, etc...
+    # yield up, and then clean things up afterwards.
+    def setup(env)
+      exception = nil
+      log_request do
+        @request = Mack::Request.new(env) 
+        @response = Mack::Response.new
+        @cookies = Mack::CookieJar.new(self.request, self.response)
+        session do
+          begin
+            yield
+          rescue Exception => e
+            exception = e
+          end
+        end
+      end
+      raise exception if exception
+      self.response.finish
+    end
+    
+    def session
+      sess_id = self.cookies[app_config.mack.session_id]
+      unless sess_id
+        sess_id = create_new_session
+      else
+        sess = Cachetastic::Caches::MackSessionCache.get(sess_id)
+        if sess
+          self.request.session = sess
+        else
+          # we couldn't find it in the store, so we need to create it:
+          sess_id = create_new_session
+        end
+      end
+
+      yield
+      
+      Cachetastic::Caches::MackSessionCache.set(sess_id, self.request.session)
+    end
+    
+    def create_new_session
+      id = String.randomize(40).downcase
+      self.cookies[app_config.mack.session_id] = {:value => id, :expires => nil}
+      sess = Mack::Session.new(id)
+      self.request.session = sess
+      Cachetastic::Caches::MackSessionCache.set(id, sess)
+      id
+    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::Configuration.public_directory, env["PATH_INFO"]))
+        return Rack::File.new(File.join(Mack::Configuration.public_directory)).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/utils/mime_types.rb

@@ -0,0 +1,56 @@
+module Mack
+  module Utils
+    # Houses the MimeTypes used by the system to set the proper 'Content-Type' for requests.
+    class MimeTypes
+      include Singleton
+      
+      def initialize # :nodoc:
+        @types = YAML.load(File.open(File.join(File.dirname(__FILE__), "mime_types.yml")))
+      end
+      
+      # Registers a new mime-type to the system. If the key already exists, it will
+      # be appended to the existing type.
+      # 
+      # Examples:
+      # Mack::Utils::MimeTypes.register(:iphone, "app/iphone")
+      #   "/users.iphone" # => will have a 'Content-Type' header of "app/iphone"
+      # Mack::Utils::MimeTypes.register(:iphone, "application/mac-iphone")
+      #   "/users.iphone" # => will have a 'Content-Type' header of "app/iphone; application/mac-iphone"
+      def register(name, type)
+        name = name.to_sym
+        if @types.has_key?(name)
+          @types[name] << "; " << type
+        else
+          @types[name] = type
+        end
+      end
+      
+      # Returns the type registered for the key, if there is no type for the key,
+      # then "text/html" is returned
+      # 
+      # Examples:
+      # Mack::Utils::MimeTypes.get(:iphone)
+      #   # => "app/iphone"
+      # Mack::Utils::MimeTypes.get(:i_dont_exist)
+      #   # => "text/html"
+      def get(name)
+        @types[name.to_sym] || "text/html"
+      end
+      
+      class << self
+        
+        # Maps to Mack::Utils::MimeTypes.instance.get
+        def [](name)
+          Mack::Utils::MimeTypes.instance.get(name.to_sym)
+        end
+        
+        # Maps to Mack::Utils::MimeTypes.instance.register
+        def register(name, type)
+          Mack::Utils::MimeTypes.instance.register(name, type)
+        end
+        
+      end
+      
+    end # MimeTypes
+  end # Utils
+end # Mack