mack 0.0.3

data/initialize/configuration.rb

@@ -0,0 +1,99 @@
+module Mack
+  # All configuration for the Mack subsystem happens here. Each of the default environments,
+  # production, development, and test have their own default configuration options. These
+  # get merged with overall default options.
+  module Configuration # :nodoc:
+
+    # use local memory and store stuff for 24 hours:
+    # use file for sessions and store them for 4 hours: 
+    DEFAULTS_PRODUCTION = {
+      "mack::use_lint" => false,
+      "mack::show_exceptions" => false,
+      "log::level" => "info",
+      "log::detailed_requests" => false,
+      "cachetastic_default_options" => {
+        "debug" => false,
+        "adapter" => "local_memory",
+        "expiry_time" => 86400,
+        "logging" => {
+          "logger_1" => {
+            "type" => "file",
+            "file" => File.join(MACK_ROOT, "log", "cachetastic.log")
+          }
+        }
+      },
+      "cachetastic_caches_mack_session_cache_options" => {
+        "debug" => false,
+        "adapter" => "file",
+        "store_options" => 
+          {"dir" => File.join(MACK_ROOT, "tmp")},
+        "expiry_time" => 14400,
+        "logging" => {
+          "logger_1" => {
+            "type" => "file",
+            "file" => File.join(MACK_ROOT, "log", "cachetastic.log")
+          }
+        }
+      }
+    } unless self.const_defined?("DEFAULTS_PRODUCTION")
+    
+    # use local memory and store stuff for 5 minutes:
+    DEFAULTS_DEVELOPMENT = {
+      "mack::cache_classes" => false,
+      "log::level" => "debug",
+      "log::console" => true,
+      "cachetastic_default_options" => {
+        "debug" => false,
+        "adapter" => "local_memory",
+        "expiry_time" => 300,
+        "logging" => {
+          "logger_1" => {
+            "type" => "file",
+            "file" => File.join(MACK_ROOT, "log", "cachetastic.log")
+          }
+        }
+      }
+    } unless self.const_defined?("DEFAULTS_DEVELOPMENT")
+    
+    # use local memory and store stuff for 1 hour:
+    DEFAULTS_TEST = {
+      "log::level" => "error",
+      "cachetastic_default_options" => {
+        "debug" => false,
+        "adapter" => "local_memory",
+        "expiry_time" => 3600,
+        "logging" => {
+          "logger_1" => {
+            "type" => "file",
+            "file" => File.join(MACK_ROOT, "log", "cachetastic.log")
+          }
+        }
+      }
+    } unless self.const_defined?("DEFAULTS_TEST")
+    
+    unless self.const_defined?("DEFAULTS")
+      DEFAULTS = {
+        "mack::cache_classes" => true,
+        "mack::use_lint" => true,
+        "mack::show_exceptions" => true,
+        "mack::session_id" => "_mack_session_id",
+        "mack::cookie_values" => {
+          "path" => "/"
+        },
+        # "mack::orm" => "activerecord",
+        "log::detailed_requests" => true,
+        "log::level" => "info",
+        "log::console" => false,
+        "log::file" => true,
+        "log::console_format" => "%l:\t[%d]\t%M",
+        "log::file_format" => "%l:\t[%d]\t%M"
+      }.merge(eval("DEFAULTS_#{MACK_ENV.upcase}"))
+    end
+    
+    app_config.load_hash(DEFAULTS, "mack_defaults")
+    app_config.load_file(File.join(MACK_CONFIG, "app_config", "default.yml"))
+    app_config.load_file(File.join(MACK_CONFIG, "app_config", "#{MACK_ENV}.yml"))
+    # app_config.reload
+    
+  end
+end

data/initialize/configure_logging.rb

@@ -0,0 +1,24 @@
+#--
+# Configure logging
+#++
+include Log4r
+
+log_dir_loc = File.join(MACK_ROOT, "log")
+FileUtils.mkdir_p(log_dir_loc)
+
+unless Object.const_defined?("MACK_DEFAULT_LOGGER")
+  log = Log4r::Logger.new('')
+  log.level =  Module.instance_eval("Log4r::#{app_config.log.level.to_s.upcase}")
+  # console:
+  if app_config.log.console
+    console_format = PatternFormatter.new(:pattern => app_config.log.console_format)
+    log.add(Log4r::StdoutOutputter.new('console', :formatter => console_format))
+  end
+  # file:
+  if app_config.log.file
+    file_format = PatternFormatter.new(:pattern => app_config.log.file_format)
+    log.add(FileOutputter.new('fileOutputter', :filename => File.join(log_dir_loc, "#{MACK_ENV}.log"), :trunc => false, :formatter => file_format))
+  end
+  
+  Object::MACK_DEFAULT_LOGGER = log
+end

data/initialize/configure_orm_support.rb

@@ -0,0 +1,23 @@
+# setup ORM:
+
+[:activerecord, :data_mapper].each do |orm|
+  eval("def using_#{orm}?; false; end")
+end
+
+unless app_config.mack.orm.nil?
+  dbs = YAML::load(ERB.new(IO.read(File.join(MACK_CONFIG, "database.yml"))).result)
+  case app_config.mack.orm
+  when 'activerecord'
+    require 'activerecord'
+    ActiveRecord::Base.establish_connection(dbs[MACK_ENV])
+    eval("def using_activerecord?; true; end")
+  when 'data_mapper'
+    require 'data_mapper'
+    DataMapper::Database.setup(dbs[MACK_ENV])
+    eval("def using_data_mapper?; true; end")
+  else
+    MACK_DEFAULT_LOGGER.warn("Attempted to configure an unknown ORM: #{app_config.mack.orm}")
+  end
+else
+  MACK_DEFAULT_LOGGER.warn("No ORM has been configured!")
+end

data/initialize/console.rb

@@ -0,0 +1,13 @@
+# This file gets loaded when you run:
+#   rake console
+# It loads the following classes to make using the application via the console easier:
+# 
+# * Mack::TestHelpers
+# * Mack::Routes::Urls
+
+fl = File.join(File.dirname(__FILE__), "..")
+
+require File.join(fl, "test_extensions", "test_helpers")
+
+self.send(:include, Mack::TestHelpers)
+self.send(:include, Mack::Routes::Urls)

data/initialize/initializer.rb

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'rack'
+require 'digest'
+require 'ruby_extensions'
+require 'application_configuration'
+require 'cachetastic'
+require 'fileutils'
+require 'log4r'
+
+# Set up Mack constants, if they haven't already been set up.
+unless Object.const_defined?("MACK_ENV")
+  (Object::MACK_ENV = (ENV["MACK_ENV"] ||= "development")).to_sym
+end
+(Object::MACK_ROOT = (ENV["MACK_ROOT"] ||= FileUtils.pwd)) unless Object.const_defined?("MACK_ROOT")
+
+Object::MACK_PUBLIC = File.join(MACK_ROOT, "public") unless Object.const_defined?("MACK_PUBLIC")
+Object::MACK_APP = File.join(MACK_ROOT, "app") unless Object.const_defined?("MACK_APP")
+Object::MACK_LIB = File.join(MACK_ROOT, "lib") unless Object.const_defined?("MACK_LIB")
+Object::MACK_CONFIG = File.join(MACK_ROOT, "config") unless Object.const_defined?("MACK_CONFIG")
+Object::MACK_VIEWS = File.join(MACK_APP, "views") unless Object.const_defined?("MACK_VIEWS")
+Object::MACK_LAYOUTS = File.join(MACK_VIEWS, "layouts") unless Object.const_defined?("MACK_LAYOUTS")
+
+unless Object.const_defined?("MACK_INITIALIZED")
+  puts "Starting application in #{MACK_ENV} mode."
+  
+  Object::MACK_INITIALIZED = true
+  
+  # Set up 'Rails' constants to allow for easier use of existing gems/plugins like application_configuration.
+  # I would like to take these out eventually, but for right now, it's not doing too much harm.
+  # Object::RAILS_ENV = MACK_ENV unless Object.const_defined?("RAILS_ENV")
+  # Object::RAILS_ROOT = MACK_ROOT unless Object.const_defined?("RAILS_ROOT")
+
+  require File.join(File.dirname(__FILE__), "configuration.rb")
+
+  require File.join(File.dirname(__FILE__), "configure_logging.rb")
+  
+  require File.join(File.dirname(__FILE__), "configure_orm_support.rb")
+
+  fl = File.join(File.dirname(__FILE__), "..")
+
+  # Require all the necessary files to make Mack actually work!
+  ["errors", "core_extensions", "lib", "test_extensions", "routing", "sea_level", "tasks", "initialize/server"].each do |dir|
+    dir_globs = Dir.glob(File.join(fl, dir, "**/*.rb"))
+    dir_globs.each do |d|
+      require d
+    end
+  end
+  
+
+
+  # ------------------------------------------------------------------------
+
+  # set up application stuff:
+
+  # set up routes:
+  require File.join(MACK_ROOT, "config", "routes")
+
+  # require 'app' files:
+  Dir.glob(File.join(MACK_APP, "**/*.rb")).each do |d|
+    require d
+  end
+  
+  # require 'lib' files:
+  Dir.glob(File.join(MACK_LIB, "**/*.rb")).each do |d|
+    require d
+  end
+
+
+  # ------------------------------------------------------------------------ 
+  
+  # Include ApplicationHelper into all controllers:
+  if Object.const_defined?("ApplicationHelper")
+    ApplicationHelper.include_safely_into(Mack::Controller::Base, Mack::ViewBinder)
+  end
+  # Find other Helpers and include them into their respective controllers.
+  Object.constants.collect {|c| c if c.match(/Controller$/)}.compact.each do |cont|
+    if Object.const_defined?("#{cont}Helper")
+      h = "#{cont}Helper".constantize
+      h.include_safely_into(cont, Mack::ViewBinder)
+    end
+  end
+  
+  # Find view level Helpers and include them into the Mack::ViewBinder
+  Mack::ViewHelpers.constants.each do |cont|
+      h = "Mack::ViewHelpers::#{cont}".constantize
+      h.include_safely_into(Mack::ViewBinder)
+  end
+end

data/initialize/server/simple_server.rb

@@ -0,0 +1,21 @@
+module Mack
+  # Even though it's called, SimpleServer, this might be the only server you need to run
+  # a Mack application.
+  # 
+  #   $ ruby script/server
+  # 
+  # This SimpleServer does not use Thin. But does work with anything that Rack has a handler for.
+  class SimpleServer
+    
+    class << self
+      
+      def run(options)
+        r = "Rack::Handler::#{options.handler.camelcase}"
+        puts "Starting app using: #{r} in #{options.environment} mode on port: #{options.port}"
+        eval(r).run(Mack::Utils::Server.build_app, :Port => options.port)
+      end
+      
+    end
+    
+  end
+end

data/lib/utils/html.rb

@@ -0,0 +1,88 @@
+module Mack
+  module Utils
+    # Useful utilities for dealing with HTML.
+    class Html
+      
+      class << self
+        
+        # Used in views to create href links. It takes link_text, url, and a Hash that gets added
+        # to the href as options.
+        # 
+        # Examples:
+        #    Mack::Utils::Html.href("http://www.mackframework.com") # => <a href="http://www.mackframework.com">http://www.mackframework.com</a>
+        #    Mack::Utils::Html.href("Mack", "http://www.mackframework.com") # => <a href="http://www.mackframework.com">Mack</a>
+        #    Mack::Utils::Html.href("Mack", "http://www.mackframework.com", :target => "_blank") # => <a href="http://www.mackframework.com" target="_blank">Mack</a>
+        #    Mack::Utils::Html.href("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.
+        #    Mack::Utils::Html.href("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.
+        #    Mack::Utils::Html.href("Mack", "http://www.mackframework.com", :method => :delete, :confirm => "Are you sure?")
+        def href(link_text, url = link_text, html_options = {})
+          if html_options[:method]
+            meth = nil
+            confirm = nil
+
+            meth = %{var f = document.createElement('form'); f.style.display = 'none'; this.parentNode.appendChild(f); f.method = 'POST'; f.action = this.href;var s = document.createElement('input'); s.setAttribute('type', 'hidden'); s.setAttribute('name', '_method'); s.setAttribute('value', '#{html_options[:method]}'); f.appendChild(s);f.submit()}
+            html_options.delete(:method)
+
+            if html_options[:confirm]
+              confirm = %{if (confirm('#{html_options[:confirm]}'))}
+              html_options.delete(:confirm)
+            end
+
+            html_options[:onclick] = (confirm ? (confirm + " { ") : "") << meth << (confirm ? (" } ") : "") << ";return false;"
+          end
+
+          html = "<a href=" << '"' << url
+          html << '"'
+          html << " " << html_options.join("%s=\"%s\"", " ") unless html_options.empty?
+          html << ">" << link_text
+          html << "</a>"
+          html
+        end
+        
+        alias_method :a, :href
+        
+        # Wraps the content_tag method.
+        # 
+        # Examples:
+        #   Mack::Utils::Html.b("hello") # => <b>hello</b>
+        #   Mack::Utils::Html.div("hello world!", :class => :foo)) # => <div class="foo">hello world!</div>
+        def method_missing(sym, *args)
+          ags = args.from_args
+          
+          tag = sym
+          content = nil
+          options = {}
+          
+          if ags.is_a?(Array)
+            content = ags[0] if ags[0].is_a?(String)
+            options = ags[1] if ags[1].is_a?(Hash)
+          elsif ags.is_a?(String)
+            content = ags
+          elsif ags.is_a?(Hash)
+            options = ags
+          end
+          
+          content = yield if block_given?
+          
+          content_tag(tag, content, options)
+        end
+        
+        # Builds an HTML tag.
+        # 
+        # Examples:
+        #   content_tag(:b, "hello") # => <b>hello</b>
+        #   content_tag("div", "hello world!", :class => :foo) # => <div class="foo">hello world!</div>
+        def content_tag(tag, content, options = {})
+          html = "<#{tag} #{options.join("%s=\"%s\"", " ")}>#{content}</#{tag}>"
+        end
+        
+      end # self
+      
+    end # Html
+  end # Utils
+end # Mack

data/lib/utils/server.rb

@@ -0,0 +1,27 @@
+module Mack
+  module Utils
+    module Server
+    
+      # This method wraps all the necessary components of the Rack system around
+      # Mack::Runner. This can be used build your own server around the Mack framework.
+      def self.build_app
+        # Mack framework:
+        app = Mack::Runner.new
+        # Any urls listed will go straight to the public directly and will not be served up via the app:
+        app = Rack::Static.new(app, :urls => ["/css", "/images", "/files", "/images", "/stylesheets", "/javascripts", "/media"], :root => "public")
+        app = Rack::Lint.new(app) if app_config.mack.use_lint 
+        app = Rack::ShowStatus.new(app) 
+        app = Rack::ShowExceptions.new(app) if app_config.mack.show_exceptions
+        app = Rack::Recursive.new(app)
+        # This will reload any edited classes if the cache_classes config setting is set to true.
+        app = Rack::Reloader.new(app, 1) unless app_config.mack.cache_classes
+        # TODO: Not sure about this logger, investigate better ones.
+        # TODO: Depends on MACK_DEFAULT_LOGGER already being configured.
+        # This makes it a drag run this 'standalone' in another Ruby program.
+        # app = Rack::CommonLogger.new(app, MACK_DEFAULT_LOGGER)
+        app
+      end
+    
+    end # Server
+  end # Utils
+end # Mack

data/mack.rb

@@ -0,0 +1,124 @@
+require File.join(File.dirname(__FILE__), "initialize", "initializer")
+
+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)
+      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:
+              c = "#{route[:controller].to_s.camelcase}Controller".constantize.new(self.request, self.response, self.cookies)
+              self.response.write(c.run)
+            end
+          rescue Mack::Errors::ResourceNotFound, Mack::Errors::UndefinedRoute => e
+            return try_to_find_resource(env, self.request.path_info, 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)
+      log_request do
+        @request = Mack::Request.new(env) 
+        @response = Mack::Response.new
+        @cookies = Mack::CookieJar.new(self.request, self.response)
+        session do
+          yield
+        end
+        self.response.finish
+      end
+    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)
+    end
+    
+    def try_to_find_resource(env, path_info, exception)
+      # we can't find a route for this, so let's try and see if it's in the public directory:
+      if File.extname(path_info).blank?
+        path_info << ".html"
+      end
+      if File.exists?(File.join(MACK_PUBLIC, path_info))
+        return Rack::File.new(File.join(MACK_PUBLIC)).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]
+      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