mack 0.0.3

data/sea_level/cookie_jar.rb

@@ -0,0 +1,67 @@
+module Mack
+  
+  # Examples:
+  #   class MyAwesomeController < Mack::Controller::Base
+  #     def index
+  #       cookies[:id] = 1
+  #       render(:text => "Hello!")
+  #     end
+  # 
+  #     def show
+  #       render(:text => "The id in the cookie is: #{cookies[:id]}")
+  #     end
+  #   end
+  class CookieJar
+    
+    attr_reader :all_cookies # :nodoc:
+    attr_reader :request # :nodoc:
+    attr_reader :response # :nodoc:
+    
+    def initialize(request, response) # :nodoc:
+      @request = request
+      @response = response
+      @all_cookies = request.cookies
+    end
+    
+    # Returns the value of a cookie as a String, or nil it doesn't exist.
+    # This will check both the incoming cookies on the request, as well as
+    # any cookies that have been set as part of the current action.
+    def [](key)
+      return nil if key.nil?
+      # check both the incoming cookies and the outgoing cookies to see if 
+      # the cookie we're looking for exists.
+      c = (self.all_cookies[key.to_s] || self.all_cookies[key.to_sym])
+      return c if c.is_a?(String)
+      return c[:value] if c.is_a?(Hash)
+      return nil
+    end
+    
+    # Set a cookie with a specified value.
+    def []=(key, value)
+      key = key.to_s
+      unless value.is_a?(Hash)
+        value = {:value => value}
+      end
+      value = app_config.mack.cookie_values.merge(value)
+      self.all_cookies[key] = value
+      self.response.set_cookie(key, value)
+    end
+    
+    # Deletes a cookie.
+    def delete(key)
+      key = key.to_s
+      self.all_cookies.delete(key)
+      self.response.delete_cookie(key)
+    end
+    
+    # Returns both cookies that came in as part of the request, as well as those set
+    # on to the response. This is useful when you set a cookie in a filter or an action
+    # and want to access it in another filter or action before the request/response has
+    # been fully completed.
+    def all
+      self.all_cookies
+    end
+    
+  end # CookieJar
+  
+end # Mack

data/sea_level/filter.rb

@@ -0,0 +1,63 @@
+module Mack
+  module Controller
+    # A wrapper class to hold calls to filter methods for Controllers.
+    # This class should never be called by itself. Instead there are helper
+    # methods in Mack::Controller::Base to do this for.
+    # 
+    # Examples:
+    #   class MyAwesomeController < Mack::Controller::Base
+    #     # all actions in this controller will have this filter run:
+    #     before_filter: authenticate
+    #     # only the show and index actions in this controller will have this filter run:
+    #     before_filter: load_side_bar, :only => [:show, :index]
+    #     # all actions, except for the create action will have this filter run.
+    #     after_filter: write_to_log, :except => :create
+    #   end
+    # 
+    # Filter methods need to be scoped to the controller that is to run them.
+    # There are three different filters available: <tt>before</tt>, <tt>after</tt> and <tt>after_render</tt>.
+    # 
+    # <tt>before</tt> filters get run before an action is called. This is a great place to set up common
+    # elements needed for your action. Things like authentication should be done here, etc...
+    # 
+    # <tt>after</tt> filters get run after an action has been called. This is a great place to set up common
+    # elements for a view, that depend on stuff from inside your action. Because nothing has been 'rendered'
+    # yet, you still can add new instance variables, and alter ones created in the action.
+    # 
+    # <tt>after_render</tt> filters get run after the rendering of the action has happened. At this point
+    # there is an instance variable, <tt>@final_rendered_action</tt>, that is available on which work can be done.
+    # This variable will have any layouts rendered to, any ERB will have been processed, etc... It should be the final
+    # String that will get rendered to the screen. This is a great place to do things like write a log, gzip, etc...
+    class Filter
+  
+      attr_reader :filter_method
+      attr_reader :action_list
+  
+      def initialize(filter_method, action_list = {})
+        @filter_method = filter_method
+        clean_action_list(action_list)
+      end
+  
+      def run?(action)
+        return true if action_list.empty?
+        if action_list[:only]
+          return action_list[:only].include?(action)
+        elsif action_list[:except]
+          return !action_list[:except].include?(action)
+        end
+        return false
+      end
+    
+      private
+      def clean_action_list(action_list)
+        if action_list[:only]
+          action_list[:only] = [action_list[:only]].flatten
+        elsif action_list[:except]
+          action_list[:except] = [action_list[:except]].flatten
+        end
+        @action_list = action_list
+      end
+  
+    end # Fitler
+  end # Controller
+end # Mack

data/sea_level/helpers/view_helpers/html_helpers.rb

@@ -0,0 +1,33 @@
+module Mack
+  module ViewHelpers
+    module HtmlHelpers
+      
+      # This is just an alias to Mack::Utils::Html.
+      # 
+      # Examples:
+      #   <%= link_to("http://www.mackframework.com") %> # => <a href="http://www.mackframework.com">http://www.mackframework.com</a>
+      #   <%= link_to("Mack", "http://www.mackframework.com") %> # => <a href="http://www.mackframework.com">Mack</a>
+      #   <%= link_to("Mack", "http://www.mackframework.com", :target => "_blank") %> # => <a href="http://www.mackframework.com" target="_blank">Mack</a>
+      #   <%= link_to("Mack", "http://www.mackframework.com", :target => "_blank", :rel => :nofollow) %> # => <a href="http://www.mackframework.com" target="_blank" rel="nofollow">Mack</a>
+      # If you pass in :method as an option it will be a JavaScript form that will post to the specified link with the 
+      # methd specified.
+      #   <%= link_to("Mack", "http://www.mackframework.com", :method => :delete) %>
+      # If you use the :method option you can also pass in a :confirm option. The :confirm option will generate a 
+      # javascript confirmation window. If 'OK' is selected the the form will submit. If 'cancel' is selected, then
+      # nothing will happen. This is extremely useful for 'delete' type of links.
+      #   <%= link_to("Mack", "http://www.mackframework.com", :method => :delete, :confirm => "Are you sure?") %>
+      def link_to(link_text, url = link_text, html_options = {})
+        Mack::Utils::Html.href(link_text, url, html_options)
+      end
+      
+      # A wrapper method for views that calls out to Mack::Utils::Html.
+      # 
+      # Examples:
+      #   <%= html.b("hello") %> # => <b>hello</b>
+      def html
+        Mack::Utils::Html
+      end
+      
+    end # HtmlHelpers
+  end # ViewHelpers
+end # Mack

data/sea_level/helpers/view_helpers/orm_helpers.rb

@@ -0,0 +1,72 @@
+if using_activerecord?
+  class ActiveRecord::Base # :nodoc:
+    def business_display_name
+      self.class.name#.titlecase
+    end
+  end
+end
+
+if using_data_mapper?
+  class DataMapper::Base # :nodoc:
+    def business_display_name
+      self.class.name#.titlecase
+    end
+  end
+end
+
+module Mack
+  module ViewHelpers
+    module OrmHelpers
+      DEFAULT_PARTIAL = %{
+        <div>
+          <div class="errorExplanation" id="errorExplanation">
+            <h2>Oi, there were errors! Fix `em!</h2>
+            <ul>
+              <% for error in errors %>
+                <li><%= error %></li>
+              <% end %>  
+            </ul>
+          </div>
+        </div>
+      }
+  
+      def error_messages_for(object_names = [], view_partial = nil)
+        object_names = [object_names]
+        object_names.flatten!
+        app_errors = []
+        object_names.each do |name| 
+          object = instance_variable_get("@#{name}")
+          if object
+            object.errors.each do |key, value|
+              if value.match(/^\^/)
+                app_errors << value[1..value.length]
+              else
+                if key.class == String and key == "base"
+                  app_errors << "#{value}"
+                else
+                  app_errors << "#{object.business_display_name} #{key.underscore.split('_').join(' ').humanize} #{value}"
+                end
+              end
+            end
+          end
+        end
+        File.join(MACK_VIEWS, "application", "_error_messages.html.erb")
+        unless app_errors.empty?
+          if view_partial.nil?
+            if File.exist?(File.join(MACK_VIEWS, "application", "_error_messages.html.erb"))
+              render :partial => "application/error_messages", :locals => {:errors => app_errors}
+            else
+              render :text => DEFAULT_PARTIAL, :locals => {:errors => app_errors}
+            end
+          else        
+            render :partial => view_partial, :locals => {:errors => app_errors}
+          end
+        else
+          ""
+        end
+      end
+  
+      # self.include_safely_into(Mack::ViewBinder)
+    end # OrmHelpers
+  end # ViewHelpers
+end # Mack

data/sea_level/request.rb

@@ -0,0 +1,83 @@
+module Mack
+  class Request < Rack::Request
+    
+    def initialize(env) # :nodoc:
+      super(env)
+      @mack_params = {}
+      parse_params(rack_params)
+    end
+    
+    alias_method :rack_params, :params # :nodoc:
+    
+    # Returns all parameters associated with this request.
+    def all_params
+      @mack_params
+    end
+    
+    # Merges another Hash with the parameters for this request.
+    def merge_params(opts = {})
+      parse_params(opts)
+    end
+    
+    # Gives access to the session. See Mack::Session for more information.
+    attr_accessor :session 
+    
+    # Examples:
+    #  http://example.org
+    #  https://example.org
+    #  http://example.org:8080
+    def full_host
+      u = self.scheme.dup
+      u << "://"
+      u << self.host.dup
+      unless self.port == 80 || self.port == 443
+        u << ":#{self.port}"
+      end
+      u
+    end
+    
+    # Examples:
+    #  http://example.org:80
+    #  https://example.org:443
+    #  http://example.org:8080
+    def full_host_with_port
+      full_host << ":#{self.port}"
+    end
+    
+    # Gives access to the request parameters. This includes 'get' parameters, 'post' parameters
+    # as well as parameters from the routing process. The parameter will also be 'unescaped'
+    # when it is returned.
+    # 
+    # Example:
+    #   uri: '/users/1?foo=bar'
+    #   route: '/users/:id' => {:controller => 'users', :action => 'show'}
+    #   parameters: {:controller => 'users', :action => 'show', :id => 1, :foo => "bar"}
+    def params(key)
+      p = (@mack_params[key.to_sym] || @mack_params[key.to_s])
+      unless p.nil?
+        p = p.to_s if p.is_a?(Symbol)
+        if p.is_a?(String)
+          p = Rack::Utils.unescape(p)
+        elsif p.is_a?(Hash)
+          p.each_pair {|k,v| p[k] = Rack::Utils.unescape(v)}
+        end
+      end
+      p
+    end
+    
+    private
+    def parse_params(ps)
+      ps.each_pair do |k, v|
+        if k.to_s.match(/.+\[.+\]/)
+          nv = k.to_s.match(/.+\[(.+)\]/).captures.first
+          nk = k.to_s.match(/(.+)\[.+\]/).captures.first
+          @mack_params[nk.to_sym] = {} if @mack_params[nk.to_sym].nil?
+          @mack_params[nk.to_sym].merge!(nv.to_sym => v)
+        else
+          @mack_params[k.to_sym] = v
+        end
+      end
+    end
+    
+  end
+end

data/sea_level/response.rb

@@ -0,0 +1,6 @@
+module Mack
+  # Right now Mack::Response is just a wrapper around Rack::Response.
+  # Down the line this may be used to spice up the response.
+  class Response < Rack::Response
+  end
+end

data/sea_level/session.rb

@@ -0,0 +1,33 @@
+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
+  # system like such:
+  #   mack::session_id: _my_cool_app_sess_id
+  class Session
+    
+    attr_reader :id # The id of the session.
+    
+    def initialize(id)
+      @id = id
+      @sess_hash = {}
+    end
+    
+    # Finds what you're looking for in the session, if it exists.
+    # If what you're looking for doesn't exist, it returns nil.
+    def [](key)
+      sess_hash[key.to_sym]
+    end
+    
+    # Sets a value into the session.
+    def []=(key, value)
+      sess_hash[key.to_sym] = value
+    end
+    
+    private
+    attr_reader :sess_hash # :nodoc:
+    
+  end # Session
+  
+end # Mack

data/sea_level/view_binder.rb

@@ -0,0 +1,101 @@
+# require 'erubis'
+# This class is used to do all the view level bindings.
+# It allows for seperation between the controller and the view levels.
+class Mack::ViewBinder
+  
+  attr_accessor :controller # Allows access to the controller.
+  attr_accessor :options # Allows access to any options passed into the Binder.
+  
+  def initialize(cont, opts = {})
+    self.controller = cont
+    self.options = {:locals => {}}.merge(opts)
+    transfer_vars(@controller)
+  end
+  
+  # Returns the binding for this class.
+  def view_binding
+    binding
+  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)
+    self.options[:locals][sym]
+  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) %>
+  def render(options = {})
+    if options[:action]
+      begin
+        # Try to render the action:
+        return render_file(options[:action], options)
+      rescue Errno::ENOENT => e
+        begin
+          # If the action doesn't exist on disk, try to render it from the public directory:
+          t = render_file(options[:action], {:dir => MACK_PUBLIC, :ext => ".html", :layout => false}.merge(options))
+          # Because it's being served from public don't wrap a layout around it!
+          # self.controller.instance_variable_get("@render_options").merge!({:layout => false})
+          return t
+        rescue Errno::ENOENT => ex
+        end
+        # Raise the original exception because something bad has happened!
+        raise e
+      end
+    elsif options[:text]
+      return Mack::ViewBinder.render(options[:text], self.controller, options)
+    elsif options[:partial]
+      return render_file(options[:partial], {:is_partial => true}.merge(options))
+    elsif options[:public]
+      t = render_file(options[:public], {:dir => MACK_PUBLIC, :ext => ".html", :layout => false}.merge(options))
+      # self.controller.instance_variable_get("@render_options").merge!({:layout => false})
+      return t
+    else
+      raise Mack::UnknownRenderOption.new(options)
+    end
+  end
+  
+  private
+  def render_file(f, options = {})
+    options = {:is_partial => false, :ext => ".html.erb", :dir => MACK_VIEWS}.merge(options)
+    partial = f.to_s
+    parts = partial.split("/")
+    if parts.size == 1
+      # it's local to this controller
+      partial = "_" << partial if options[:is_partial]
+      partial = File.join(options[:dir], self.controller.controller_name, partial + options[:ext])
+    else
+      # it's elsewhere
+      parts[parts.size - 1] = "_" << parts.last if options[:is_partial]
+      partial = File.join(options[:dir], parts.join("/") + options[:ext])
+    end
+    return Mack::ViewBinder.render(File.open(partial).read, self.controller, options)
+  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
+  
+  class << self
+    
+    # Creates a Mack::ViewBinder and then passes the io through ERB
+    # and returns a String. The io can be either an IO object or a String.
+    def render(io, controller, options = {})
+      vb = Mack::ViewBinder.new(controller, options)
+      return ERB.new(io).result(vb.view_binding)
+      # return Erubis::Eruby.new(io).result(vb.view_binding)
+    end
+    
+  end
+  
+end