mack 0.5.0 → 0.5.5

data/lib/distributed/utils/rinda.rb

@@ -9,7 +9,7 @@ module Mack
           begin
             ring_server.take([options[:space], options[:klass_def], nil, nil], options[:timeout])
           rescue Exception => e
-            puts e.message
+            # MACK_DEFAULT_LOGGER.error(e)
           end
           register(options)
         end

data/lib/errors/errors.rb

@@ -6,8 +6,8 @@ module Mack
     # Example:
     #   class FooController < Mack::Controller::Base
     #     def index
-    #       render(:text => "Hello World")
-    #       render(:action => "edit")
+    #       render(:text,  "Hello World")
+    #       render(:action, "edit")
     #     end
     #   end
     class DoubleRender < StandardError
@@ -86,12 +86,14 @@ module Mack
       end
     end
     
-    # Potentially raised if a render(:url => "....") is a status other than 200.
+    # Potentially raised if a render(:url, "....") is a status other than 200.
     # This is only raised if :raise_exception is passed in as true to the render options.
     class UnsuccessfulRenderUrl < StandardError
       # Takes the uri trying to be rendered the Net::HTTP response object.
       def initialize(uri, response)
-        super("URI: #{uri}; status: #{response.code}; body: #{response.body}")
+        code = response.code if response.respond_to?(:code)
+        code = response.status if response.respond_to?(:status)
+        super("URI: #{uri}; status: #{code}")
       end
     end
     

data/lib/generators/mack_application_generator/templates/config/initializers/mime_types.rb.template

@@ -0,0 +1,3 @@
+# Register mime types for a file extension in this file.
+# Example:
+# Mack::Utils::MimeTypes.register(:iphone, "app/iphone")

data/lib/initialization/configuration.rb

@@ -59,7 +59,8 @@ module Mack
     DEFAULTS_TEST = {
       "log::level" => "error",
       "run_remote_tests" => true,
-      "mack::drb_timeout" => 0
+      "mack::drb_timeout" => 0,
+      "mack::cookie_values" => {}
     } unless self.const_defined?("DEFAULTS_TEST")
     
     unless self.const_defined?("DEFAULTS")

data/lib/initialization/console.rb

@@ -5,10 +5,10 @@
 # * Mack::TestHelpers
 # * Mack::Routes::Urls
 
-require File.join(File.dirname(__FILE__), "initializer")
-
 fl = File.join(File.dirname(__FILE__), "..")
 
+require File.join(fl, "mack")
+
 require File.join(fl, "test_extensions", "test_helpers")
 
 # self.send(:include, Mack::TestHelpers)

data/lib/mack.rb

@@ -1,139 +1,115 @@
-require File.join(File.dirname(__FILE__), "initialization", "initializer")
+require 'rubygems'
+require 'rack'
+require 'digest'
+require 'mack_ruby_core_extensions'
+require 'application_configuration'
+require 'cachetastic'
+require 'fileutils'
+require 'log4r'
+require 'crypt/rijndael'
+require 'singleton'
+require 'uri'
+require 'drb'
+require 'rinda/ring'
+require 'rinda/tuplespace'
+require 'builder'
+require 'erubis'
+require 'erb'
+require 'markaby'
+require 'haml'
+require 'genosaurus'
+require 'net/http'
 
-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
+require File.join(File.dirname(__FILE__), "initialization", "configuration.rb")
 
-      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
+unless Mack::Configuration.initialized
+  
+  puts "Starting application in #{Mack::Configuration.env} mode."
+  puts "Mack root: #{Mack::Configuration.root}"
+  
+  require File.join(File.dirname(__FILE__), "initialization", "logging.rb")
+  
+  require File.join(File.dirname(__FILE__), "initialization", "orm_support.rb")
+
+  fl = File.join(File.dirname(__FILE__))
+
+  # Require all the necessary files to make Mack actually work!
+  ["distributed", "errors", "core_extensions", "utils", "test_extensions", "routing", "view_helpers", "rendering", "controller", "tasks", "initialization/server", "generators"].each do |dir|
+    dir_globs = Dir.glob(File.join(fl, dir, "**/*.rb"))
+    dir_globs.each do |d|
+      require d
     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)
+  end
+  
+
+
+  # ------------------------------------------------------------------------
+
+  # set up application stuff:
+
+  # set up routes:
+  require File.join(Mack::Configuration.config_directory, "routes")
+  
+  # set up initializers:
+  Dir.glob(File.join(Mack::Configuration.config_directory, "initializers", "**/*.rb")) do |d|
+    require d
+  end
+  Mack::Utils::GemManager.instance.do_requires
+
+  # require 'plugins':
+  require File.join(File.dirname(__FILE__), "initialization", "plugins.rb")
+  
+  # make sure that default_controller is available to other controllers
+  path = File.join(Mack::Configuration.app_directory, "controllers", "default_controller.rb")
+  require path if File.exists?(path) 
+  
+  # require 'app' files:
+  Dir.glob(File.join(Mack::Configuration.app_directory, "**/*.rb")).each do |d|
+    # puts "d: #{d}"
+    begin
+      require d
+    rescue NameError => e
+      if e.message.match("uninitialized constant")
+        mod = e.message.gsub("uninitialized constant ", "")
+        x =%{
+          module ::#{mod}
+          end
+        }
+        eval(x)
+        require d
       else
-        raise exception
+        raise e
       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
+  
+  # require 'lib' files:
+  Dir.glob(File.join(Mack::Configuration.lib_directory, "**/*.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::Rendering::ViewTemplate)
+  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::Rendering::ViewTemplate)
     end
-    
   end
-end
+  
+  # Find view level Helpers and include them into the Mack::Rendering::ViewTemplate
+  Mack::ViewHelpers.constants.each do |cont|
+      h = "Mack::ViewHelpers::#{cont}".constantize
+      h.include_safely_into(Mack::Rendering::ViewTemplate)
+  end
+  
+  Mack::Configuration.set(:initialized, "true") if Mack::Configuration.initialized.nil?
+end
+
+require File.join(File.dirname(__FILE__), "runner")

data/lib/mack_tasks.rb

@@ -5,7 +5,7 @@ require 'rubygems'
 require 'application_configuration'
 
 require File.join(File.dirname(__FILE__), "initialization", "configuration.rb")
-require File.join(File.dirname(__FILE__), "initialization", "initializers", "orm_support.rb")
+require File.join(File.dirname(__FILE__), "initialization", "orm_support.rb")
 
 # Requires all rake tasks that ship with the Mack framework.
 [File.join(File.dirname(__FILE__)), File.join(FileUtils.pwd, "lib"), File.join(FileUtils.pwd, "vendor", "plugins")].each do |dir|

data/lib/rendering/engine/base.rb

@@ -0,0 +1,26 @@
+module Mack
+  module Rendering # :nodoc:
+    module Engine # :nodoc:
+      # Engines are used to transform a IO, using a supplied binding to a String.
+      # 
+      # The method 'render' needs to be implemented as render(io, binding) in all subclasses.
+      class Base
+
+        # The Mack::Rendering::ViewTemplate object to be used with this engine.
+        attr_reader :view_template
+
+        def initialize(view_template)
+          @view_template = view_template
+        end
+        
+        # See Mack::Rendering::ViewTemplate content_for for more details.
+        def capture(*args, &block)
+          yield
+        end
+
+        needs_method :render
+
+      end # Base
+    end # Engines
+  end # Rendering
+end # Mack

data/lib/rendering/engine/builder.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), "..", "view_template")
+module Mack
+  module Rendering # :nodoc:
+    module Engine # :nodoc:
+      # Allows use of the Builder::XmlMarkup engine to be used with rendering.
+      class Builder < Mack::Rendering::Engine::Base
+        
+        def render(io, binding)
+          @_xml = ::Builder::XmlMarkup.new(:target => @_xml_output, :indent => 1)
+          view_template.instance_variable_set("@_xml", @_xml)
+          eval(io, binding)
+        end
+        
+        def extension
+          :builder
+        end
+        
+        # Used to give XmlBuilder templates access to a 'root' xml object.
+        module ViewTemplateHelpers
+          def xml
+            @_xml
+          end
+        end # ViewTemplateHelpers
+        
+      end # Builder
+    end # Engine
+  end # Rendering
+end # Mack
+
+Mack::Rendering::ViewTemplate.send(:include, Mack::Rendering::Engine::Builder::ViewTemplateHelpers)

data/lib/rendering/engine/erubis.rb

@@ -0,0 +1,67 @@
+module Mack
+  module Rendering # :nodoc:
+    module Engine # :nodoc:
+      # Allows use of the Builder::XmlMarkup engine to be used with rendering.
+      class Erubis < Mack::Rendering::Engine::Base
+        
+        def render(io, binding)
+          src = Mack::Rendering::Engine::Erubis::TemplateCache.instance.cache[io]
+          if src.nil?
+            src = ::Erubis::Eruby.new(io).src
+            Mack::Rendering::Engine::Erubis::TemplateCache.instance.cache[io] = src
+          end
+          eval(src, binding)
+        end
+        
+        def extension
+          :erb
+        end
+        
+        def concat(txt, b)
+          eval( "_buf", b) << txt
+        end
+        
+        # See Mack::Rendering::ViewTemplate content_for for more details.
+        # Thanks Merb.
+        def capture(*args, &block)
+          # get the buffer from the block's binding
+          buffer = _erb_buffer( block.binding ) rescue nil
+
+          # If there is no buffer, just call the block and get the contents
+          if buffer.nil?
+            block.call(*args)
+          # If there is a buffer, execute the block, then extract its contents
+          else
+            pos = buffer.length
+            block.call(*args)
+
+            # extract the block
+            data = buffer[pos..-1]
+
+            # replace it in the original with empty string
+            buffer[pos..-1] = ''
+
+            data
+          end
+        end
+        
+        private
+        def _erb_buffer( the_binding ) # :nodoc:
+          eval( "_buf", the_binding, __FILE__, __LINE__)
+        end
+        
+        class TemplateCache # :nodoc:
+          include Singleton
+          
+          attr_reader :cache
+          
+          def initialize
+            @cache = {}
+          end
+          
+        end
+        
+      end # Erubis
+    end # Engines
+  end # Rendering
+end # Mack