mack 0.5.5.4 → 0.6.0

data/CHANGELOG

@@ -1,3 +1,37 @@
+===0.6.0
+* INCOMPATIBILITY NOTICE: Moved Mack::Configuration.root to Mack.root
+* INCOMPATIBILITY NOTICE: Moved Mack::Configuration.env to Mack.env
+* INCOMPATIBILITY NOTICE: Mack::Configuration.* path methods no longer exist. Use mack-paths instead.
+* INCOMPATIBILITY NOTICE: Dropped mack_ruby_core_extensions in favor or mack-facets
+* INCOMPATIBILITY NOTICE: Mack::Controller::Base is now Mack::Controller (and it's now a module)
+* INCOMPATIBILITY NOTICE: Haml renderer is now part of mack-more.
+* INCOMPATIBILITY NOTICE: Markaby renderer is now part of mack-more.
+* INCOMPATIBILITY NOTICE: Changed request param's accessor routine, from params(key) to params[key]
+* INCOMPATIBILITY NOTICE: Test::Unit::TestCase is no longer the default testing framework, RSpec is. If you wish to use
+  Test::Unit::TestCase add the following config parameter to your config/app_config/default.yml file:
+  mack::testing_framework: test_case
+* INCOMPATIBILITY NOTICE: ENV["_mack_env"] and ENV["_mack_root"] are no longer supported, please use ENV["MACK_ENV"] and ENV["MACK_ROOT"], or just Mack.env and Mack.root
+* INCOMPATIBILITY NOTICE: MACK_DEFAULT_LOGGER constant is no longer available. Please use Mack.logger instead.
+* INCOMPATIBILITY NOTICE: The ApplicationHelper module is now deprecated. Please move view level helpers into Mack::ViewHelpers::* and controller helpers into Mack::ControllerHelpers::<controller_name>
+* thin.ru and thin.yml are no longer needed, you may delete them.
+* RSpec assertions are now automatically added.
+* Added a Mack::Testing::Response class to make testing of responses easier.
+* moved test_extensions to testing and added the module Testing to the files in it.
+* Added a dependency on mack-more
+* Added a set of Rake tasks to update existing Mack applications.
+* [#30] Added Mack::Logging::Filter to filter out unwanted parameters from the logs.
+* In routing you can now define a route that will catch an Exception from another controller.
+* ORM will not be initialized if the app never specify which ORM to use.
+* All Mack unit tests are now written using rspec-1.1.4.
+* mack command now takes an optional -t flag to determine which testing framework to use--value could be test_case or rspec [default]
+* new setting added to app_config: testing_framework
+* gem: cachetastic 1.7.2
+* gem: application_configuration 1.5.0
+* gem: erubis 2.6.2
+* gem: genosaurus 1.2.1
+* gem: thin 0.8.2
+* gem: rspec 1.1.4
+
 ===0.5.5.4
 * Fixed the damn Lint error some people were facing! 
 

data/README

@@ -20,7 +20,7 @@ It will try and run the app using the following servers in this order:
   * WEBrick
 
 rake script:server takes the following options:
-  $ rake script:server PORT=<port> Mack::Configuration.env=<environment> HANDLER=<rack_handler>
+  $ rake script:server PORT=<port> Mack.env=<environment> HANDLER=<rack_handler>
   
 The port and rack_handler flags don't apply if you're using Thin[http://code.macournoyer.com/thin] to run the app, which is the default if it is installed. Use the thin.yml file in your application's config directory to configure Thin. The rack_handler one will allow you to switch which server is used to run the app. See Rack for more Rack::Handlers.
   

data/bin/mack

@@ -13,7 +13,8 @@ raise "You must specify a name for this application!" if app.nil?
 
 options = OpenStruct.new
 options.orm = "data_mapper"
-options.version = "0.5.5.4"
+options.testing_framework = "rspec"
+options.version = "0.6.0"
 
 opts = OptionParser.new do |opts|
   opts.banner = "Usage: mack <application_name> [options]"
@@ -22,8 +23,12 @@ opts = OptionParser.new do |opts|
     options.orm = v
   end
   
+  opts.on("-t [rspec|test_case]") do |v|
+    options.testing_framework = v
+  end
+  
 end
 
 opts.parse!(ARGV)
 
-MackApplicationGenerator.run({"version" => options.version, "app" => app, "orm" => options.orm})
+MackApplicationGenerator.run({"version" => options.version, "app" => app, "orm" => options.orm, "testing_framework" => options.testing_framework})

data/lib/controller/controller.rb

@@ -0,0 +1,371 @@
+module Mack
+  module Controller # :nodoc:
+    # All controllers in a Mack application have to include this module. I'll be honest, if they don't extend this class
+    # then, well, things just won't work very well!
+    # 
+    # Example:
+    #   class MyAwesomeController 
+    #     include Mack::Controller
+    #
+    #     def index
+    #       render(:text, "Hello World!")
+    #     end
+    #   end
+
+    # See Mack::Request for more information.
+    attr_reader :request
+    # See Mack::Response for more information.
+    attr_reader :response
+    # The 'underscore' version of the controller requested. Example: 'my_awesome_controller'
+    attr_reader :controller_name
+    # The name of the action being requested.
+    attr_reader :action_name
+    # See Mack::CookieJar for more information.
+    attr_reader :cookies
+    # If an exception was thrown by a request this represents that error.
+    attr_accessor :caught_exception
+
+    def initialize(request, response, cookies)
+      @request = request
+      @response = response
+      @render_options = {}
+      @render_performed = false
+      @controller_name = params[:controller]
+      @action_name = params[:action]
+      @cookies = cookies
+      @wants_list = []
+    end
+
+    # Gives access to all the parameters for this request.
+    def params
+      self.request
+    end
+
+    # Gives access to the session. See Mack::Session for more information.
+    def session
+      self.request.session
+    end
+
+    # This does the heavy lifting for controllers. It calls the action, and then completes the rendering
+    # of the action to a String to send back to Rack.
+    def run
+      begin
+        run_filters(:before)
+        # check to see if this controller responds to this action.
+        # only run public methods!
+        if self.public_methods.include?(self.action_name)
+          # call the action and capture the results to a variable.
+          self.send(self.action_name)
+        else
+          # there is no action on this controller, so call the render method
+          # which will check the view directory and run action.html.erb if it exists.
+          render(:action, self.action_name)
+        end
+        run_filters(:after)
+        # do the work of rendering.
+        @final_rendered_action = do_render
+        run_filters(:after_render)
+        return @final_rendered_action
+      rescue Mack::Errors::FilterChainHalted => e
+        if render_performed?
+          run_filters(:after)
+          # do the work of rendering.
+          @final_rendered_action = do_render
+          run_filters(:after_render)
+          return @final_rendered_action
+        else
+          raise e
+        end
+      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. A server side
+    # redirect is also possible by using the option :server_side => true.
+    # When a server side redirect occurs the url must be a 'local' url, not an
+    # external url. The 'original' url of the request will NOT change.
+    def redirect_to(url, options = {})
+      options = {:status => 302}.merge(options)
+      raise Rack::ForwardRequest.new(url) if options[:server_side]
+      response.status = options[:status]
+      response[:location] = url
+      render(:text, redirect_html(request.path_info, url, options[:status]))
+    end
+
+    # In an action wants will run blocks of code based on the content type that has
+    # been requested.
+    # 
+    # Examples:
+    #   class MyAwesomeController
+    #     include Mack::Controller
+    #
+    #     def hello
+    #       wants(:html) do
+    #         render(:text, "<html>Hello World</html>")
+    #       end
+    #       wants(:xml) do
+    #         render(:text, "<xml><greeting>Hello World</greeting></xml>")
+    #       end
+    #     end
+    #   end
+    # 
+    # If you were to go to: /my_awesome/hello you would get:
+    #   "<html>Hello World</html>"
+    # 
+    # If you were to go to: /my_awesome/hello.html you would get:
+    #   "<html>Hello World</html>"
+    # 
+    # If you were to go to: /my_awesome/hello.xml you would get:
+    #   "<xml><greeting>Hello World</greeting></xml>"
+    def wants(header_type, &block)
+      header_type = header_type.to_sym
+      if header_type == params[:format].to_sym
+        yield
+      end
+    end
+
+    # Returns true/false depending on whether the render action has been called yet.
+    def render_performed?
+      @render_performed
+    end
+
+    # Gives access to the Mack.logger.
+    def logger
+      Mack.logger
+    end
+
+    # This method can be called from within an action. This 'registers' the render that you
+    # would like to happen once the action is completed.
+    # 
+    # It's important to note that calling render in an action does NOT end the processing of
+    # the action. The action will continue to process unless you explicity put 'return' before the
+    # render call.
+    # 
+    # If you call render twice in an action then a Mack::Errors::DoubleRender error will be thrown.
+    # 
+    # An implicit render will happen if one is not specified in the action.
+    # 
+    # Only :action and :text will get layouts wrapped around them.
+    #
+    # You can also specify the response status code as part of the options hash.
+    # 
+    # Examples:
+    #   class MyAwesomeController
+    #     include Mack::Controller
+    #
+    #     # This will render the text 'Hello World!' to the screen.
+    #     def index
+    #       render(:text, "Hello World!")
+    #     end
+    # 
+    #     # This will render Mack.root/views/my_awesome_controller/foo.html.erb
+    #     def show
+    #       render(:action, :foo)
+    #     end
+    # 
+    #     # This will raise a Mack::Errors::DoubleRender error.
+    #     def edit
+    #       render(:text, "Hello World!")
+    #       render(:action, :foo)
+    #     end
+    # 
+    #     # This will render Mack.root/views/my_awesome_controller/delete.html.erb
+    #     def delete
+    #     end
+    # 
+    #     # This will render the text 'Hello World!' to the screen. Assuming that
+    #     # there is no file: Mack.root/views/my_awesome_controller/update.html.erb
+    #     # The reason for this is if the view for the action doesn't exist, and the
+    #     # last thing returned from the action is a String, that string will be returned.
+    #     def update
+    #       "Hello World!"
+    #     end
+    # 
+    #     # This will raise a Mack::Errors::InvalidRenderType error. Assuming that
+    #     # there is no file: Mack.root/views/my_awesome_controller/create.html.erb
+    #     def create
+    #       @user = User.find(1)
+    #     end
+    # 
+    #     # This will raise a Errno::ENOENT error. Assuming that
+    #     # there is no file: Mack.root/views/my_awesome_controller/bar.html.erb
+    #     def bar
+    #       render(:action, "bar")
+    #     end
+    #     
+    #     # This will render a file from the public directory. Files served from the
+    #     # public directory do NOT get layouts. The default file extension for files
+    #     # served from the public directory is .html. This can be overridden with the
+    #     # :ext => ".<ext>" option.
+    #     def show_public_file
+    #       render(:public, "my/files/foo")
+    #     end
+    # 
+    #     # This will render a file from the public directory. Files served from the
+    #     # public directory do NOT get layouts. The default file extension for files
+    #     # served from the public directory is .html. This can be overridden with the
+    #     # :ext => ".<ext>" option. 
+    #     def show_public_xml_file
+    #       render(:public, "my/files/foo", :ext => ".xml")
+    #     end
+    # 
+    #     # This will render a partial. In this case it will look for:
+    #     # Mack.root/views/my_awesome_controller/_latest_news.html.erb
+    #     # Partials do NOT get wrapped in layouts.
+    #     def latest_news
+    #       render(:partial, :latest_news)
+    #     end
+    # 
+    #     # This will render a partial. In this case it will look for:
+    #     # Mack.root/views/some_other/_old_news.html.erb
+    #     # Partials do NOT get wrapped in layouts.
+    #     def latest_news
+    #       render(:partial, "some_other/old_news")
+    #     end
+    # 
+    #     # This will render a url. If the url does not return a status code of '200',
+    #     # an empty string will be returned by default. The default method for rendering
+    #     # urls is a get.
+    #     def yahoo
+    #       render(:url, "http://www.yahoo.com")
+    #     end
+    # 
+    #     # This will render a url. If the url does not return a status code of '200',
+    #     # a Mack::Errors::UnsuccessfulRenderUrl exception will be raised.
+    #     def idontexist
+    #       render(:url, "http://www.idontexist.com", :raise_exception => true)
+    #     end
+    # 
+    #     # This will render a url with a post.
+    #     def post_to_somewhere
+    #       render(:url, "http://www.mackframework.com/post_to_me", :method => :post, 
+    #              :parameters => {:id => 1, :user => "markbates"})
+    #     end
+    # 
+    #     # This will render a 'local' url. If a domain is not present render url will
+    #     # reach out for the config parameter "mack::site_domain" and prepend that
+    #     # to the url. This can be overridden locally with the :domain option.
+    #     def get_index
+    #       render(:url, "/")
+    #     end
+    #
+    #     # This will render 'application/404' and set the response status code to 404
+    #     def to_the_unknown
+    #       return render(:action, '/application/404', :status => 404)
+    #     end
+    #        
+    #   end
+    def render(render_type = :action, render_value = self.action_name, options = {})
+      raise Mack::Errors::DoubleRender.new if render_performed?
+      response.status = options[:status] unless options[:status].nil?
+      options = {:content_type => Mack::Utils::MimeTypes[params[:format]], :layout => layout}.merge(options)
+      response["Content-Type"] = options[:content_type]
+      options.delete(:content_type)
+      @view_template = Mack::Rendering::ViewTemplate.new(render_type, render_value, 
+      {:format => params[:format].to_sym, :controller => self}.merge(options))
+      @render_performed = true
+    end
+
+    private
+    def do_render
+      render unless @view_template
+      @rendered_action = @view_template.compile_and_render
+    end
+
+    def layout
+      :application
+    end
+
+    def run_filters(type)
+      filters = self.class.controller_filters[type]
+      return true if filters.empty?
+      filters.each do |filter|
+        if filter.run?(self.action_name.to_sym)
+          r = self.send(filter.filter_method)
+          raise Mack::Errors::FilterChainHalted.new(filter.filter_method) unless r
+        end
+      end
+    end
+
+    public
+    module ClassMethods
+      # See Mack::Controller::Filter for more information.
+      def before_filter(meth, options = {})
+        add_filter(:before, meth, options)
+      end
+
+      # See Mack::Controller::Filter for more information.
+      def after_filter(meth, options = {})
+        add_filter(:after, meth, options)
+      end
+
+      # See Mack::Controller::Filter for more information.
+      def after_render_filter(meth, options = {})
+        add_filter(:after_render, meth, options)
+      end
+
+      def add_filter(type, meth, options) # :nodoc:
+        controller_filters[type.to_sym] << Mack::Controller::Filter.new(meth, self, options)
+      end
+
+      def controller_filters # :nodoc:
+        unless @controller_filters
+          @controller_filters = {:before => [], :after => [], :after_render => []}
+          # inherit filters from the superclass, if any, to this parent
+          sc = self.superclass
+          if sc.class_is_a?(Mack::Controller)
+            ch = sc.controller_filters
+            [:before, :after, :after_render].each do |v|
+              @controller_filters[v] << ch[v]
+              @controller_filters[v].flatten!
+              @controller_filters[v].uniq!
+            end
+          end
+        end
+        @controller_filters
+      end
+
+      # Sets a layout to be used by a particular controller.
+      # 
+      # Example:
+      #   class MyAwesomeController
+      #     include Mack::Controller
+      #
+      #     # Sets all actions to use: "#{Mack.root}/app/views/layouts/dark.html.erb" as they're layout.
+      #     layout :dark
+      # 
+      #     def index
+      #       # Sets this action to use: "#{Mack.root}/app/views/layouts/bright.html.erb" as it's layout.
+      #       render(:text, "Welcome...", :layout => :bright)
+      #     end
+      # 
+      #     def index
+      #       # This will no use a layout.
+      #       render(:text, "Welcome...", :layout => false)
+      #     end
+      #   end
+      # 
+      # The default layout is "#{Mack.root}/app/views/layouts/application.html.erb".
+      # 
+      # If a layout is specified, and it doesn't exist a Mack::Errors::UnknownLayout error will be raised.
+      def layout(lay)
+        self.class_eval do
+          define_method(:layout) do
+            lay
+          end
+        end
+      end # layout
+
+    end # module ClassMethods
+    
+    #
+    # Make sure that all the class level methods got included into the receiver's class
+    #
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+  end # Controller
+end # Mack

data/lib/controller/cookie_jar.rb

@@ -1,7 +1,8 @@
 module Mack
   
   # Examples:
-  #   class MyAwesomeController < Mack::Controller::Base
+  #   class MyAwesomeController
+  #     include Mack::Controller
   #     def index
   #       cookies[:id] = 1
   #       render(:text,  "Hello!")