What's new in Action Pack 0.7.6?
================================

Loads of bug fixes, added an ActiveRecordStore for sessions, included 
ERB::Util so text can be escaped with just calling ΕΙ changed the 
license to MIT License.

Download from http://actionpack.rubyonrails.org, talk on #rubyonrails 
(FreeNet).


* Included ERB::Util so all templates can easily escape HTML content 
with <%=h @person.content %>

* All requests are now considered local by default, so everyone
   will be exposed to detailed debugging screens on errors.
   When the application is ready to go public, set
   ActionController::Base.consider_all_requests_local to false,
   and implement the protected method local_request? in the controller
   to determine when debugging screens should be shown.

* Fixed three bugs with the url_for/redirect_to/link_to handling. 
Considering the url http://localhost:81/friends/show/1

     url_for(:action => "list")
       ...used to give http://localhost:81/friends/list/1
       ......now gives http://localhost:81/friends/list

     url_for(:controller => "friends", :action => "destroy", :id => 5)
       ...used to give http://localhost:81/friends/destroy
       ......now gives http://localhost:81/friends/destroy/5

   Considering the url http://localhost:81/teachers/show/t

     url_for(:action => "list", :id => 5)
       ...used to give http://localhost:81/5eachers/list/t
       ......now gives http://localhost:81/teachers/list/5

   [Reported by David Morton & Radsaq]

* Logs exception to logfile in addition to showing them for local 
requests

* Protects the eruby load behind a begin/rescue block. eRuby is not 
required to run ActionController.

* Fixed install.rb to also install clean_logger and the templates

* Added ActiveRecordStore as a session option. Read more in
   lib/action_controller/session/active_record_store.rb [Tim Bates]

* Change license to MIT License (and included license file in package)

* Application error page now returns status code 500 instead of 200

* Fixed using Procs as layout handlers [Florian Weber]

* Fixed bug with using redirects ports other than 80

* Added index method that calls list on scaffolding


P.S.: The new WEBrick option for Rails will be ported to a generic 
Action Pack option in the near future.


How does Action Pack work?
==========================

Action Pack splits the response to a web request into a controller part 
(performing the logic) and a view part (rendering a template). This 
two-step approach is known as an action, which will normally create, 
read, update, or delete (CRUD for short) some sort of model part (often 
backed by a database) before choosing either to render a template or 
redirecting to another action.

Action Pack implements these actions as public methods on Action 
Controllers and uses Action Views to implement the template rendering. 
Action Controllers are then responsible for handling all the actions 
relating to a certain part of an application. This grouping usually 
consists of actions for lists and for CRUDs revolving around a single 
(or a few) model objects. So ContactController would be responsible for 
listing contacts, creating, deleting, and updating contacts. A 
WeblogController could be responsible for both posts and
comments.

Action View templates are written using embedded Ruby in tags mingled 
in with the HTML. To avoid cluttering the templates with code, a bunch 
of helper classes provide common behavior for forms, dates, and 
strings. And it's easy to add specific helpers to keep the separation 
as the application evolves.

Note: Some of the features, such as scaffolding and form building, are 
tied to ActiveRecord[http://activerecord.rubyonrails.org] (an 
object-relational mapping package), but that doesn't mean that Action 
Pack depends on Active Record. Action Pack is an independent package 
that can be used with any sort
of backend (Instiki[http://www.instiki.org], which is based on an older 
version of Action Pack, uses Madeleine for example). Read more about 
the role Action Pack can play when used together with Active Record on 
http://www.rubyonrails.org.


A short rundown of the major features
=====================================

* Actions grouped in controller as methods instead of separate command
   objects and can therefore helper share methods.

      BlogController < ActionController::Base
        def display
          @customer = find_customer
        end

        def update
          @customer = find_customer
          @customer.attributes = @params["customer"]
          @customer.save ?
            redirect_to(:action => "display") :
            render("customer/edit")
        end

        private
          def find_customer() Customer.find(@params["id"]) end
      end

    Learn more in link:classes/ActionController/Base.html


* Embedded Ruby for templates (no new "easy" template language)

      <% for post in @posts %>
        Title: <%= post.title %>
      <% end %>

      All post titles: <%= @post.collect{ |p| p.title }.join ", " %>

      <% unless @person.is_client? %>
        Not for clients to see...
      <% end %>

    Learn more in link:classes/ActionView.html


* Filters for pre and post processing of the response (as methods,
procs, and classes)

      class WeblogController < ActionController::Base
        before_filter :authenticate, :cache, :audit
        after_filter proc{|c| c.response.body =
GZip::compress(c.response.body)}
        after_filter LocalizeFilter

        def list
          # Before this action is run, the user will be authenticated,
the cache
          # will be examined to see if a valid copy of the results 
already
          # exist, and the action will be logged for auditing.

          # After this action has run, the output will first be localized
then
          # compressed to minimize bandwith usage
        end

        private
          def authenticate
            # Implement the filter will full access to both request and
response
          end
      end

    Learn more in link:classes/ActionController/Filters/ClassMethods.html


* Helpers for forms, dates, action links, and text

      <%= text_field "post", "title", "size" => 30 %>
      <%= html_date_select(Date.today) %>
      <%= link_to "New post", :controller => "post", :action => "new" %>
      <%= truncate(post.title, 25) %>

    Learn more in link:classes/ActionView/Helpers.html


* Layout sharing for template reuse (think simple version of Struts
    Tiles[http://jakarta.apache.org/struts/userGuide/dev_tiles.html])

      class WeblogController < ActionController::Base
        layout "weblog_layout"

        def hello_world
        end
      end

      Layout file (called weblog_layout):
        <html><body><%= @content_for_layout %></body></html>

      Template for hello_world action:
        <h1>Hello world</h1>

      Result of running hello_world action:
        <html><body><h1>Hello world</h1></body></html>

    Learn more in link:classes/ActionController/Layout.html


* Advanced redirection that makes pretty urls easy

      RewriteRule ^/library/books/([A-Z]+)([0-9]+)/([-_a-zA-Z0-9]+)$ \
        /books_controller.cgi?action=$3&type=$1&code=$2 [QSA] [L]

      Accessing /library/books/ISBN/0743536703/show calls
BooksController#show

      From that URL, you can rewrite the redirect in a number of ways:

      redirect_to(:action => "edit") =>
        /library/books/ISBN/0743536703/edit

      redirect_to(:path_params => { "type" => "XTC", "code" => "12354345"
}) =>
        /library/books/XTC/12354345/show

      redirect_to(:controller_prefix => "admin", :controller =>
"accounts") =>
        /admin/accounts/

    Learn more in link:classes/ActionController/Base.html


* Easy testing of both controller and template result through
TestRequest/Response

      class LoginControllerTest < Test::Unit::TestCase
        def setup
          @request = ActionController::TestRequest.new
          @request.host = "http://somewhere"
        end

        def test_succesful_authentication
            @request.action = "authenticate"
            @request.request_parameters["user_name"] = "david"
            @request.request_parameters["password"]  = "secret"

            response = LoginController.process_test(@request)

            assert_equal(
              "http://somewhere/clients/", response.headers["location"])
            assert_equal Person.find(1), response.session["person"]
            assert(response.body.split("\n").include?(
              "<h1>You've been logged in!</h1>"))
        end
      end

    Learn more in link:classes/ActionController/TestRequest.html


* Automated benchmarking and integrated logging

      Processing WeblogController#index (for 127.0.0.1 at Fri May 28
00:41:55)
      Parameters: {"action"=>"index", "controller"=>"weblog"}
      Rendering weblog/index (200 OK)
      Completed in 0.029281 (34 reqs/sec)

      If Active Record is used as the model, you'll have the database
debugging
      as well:

      Processing WeblogController#create (for 127.0.0.1 at Sat Jun 19
14:04:23)
      Params: {"controller"=>"weblog", "action"=>"create",
               "post"=>{"title"=>"this is good"} }
      SQL (0.000627) INSERT INTO posts (title) VALUES('this is good')
      Redirected to http://test/weblog/display/5
      Completed in 0.221764 (4 reqs/sec) | DB: 0.059920 (27%)

      You specify a logger through a class method, such as:

      ActionController::Base.logger = Logger.new("Application Log")
      ActionController::Base.logger = Log4r::Logger.new("Application 
Log")


* Powerful debugging mechanism for local requests

      All exceptions raised on actions performed on the request of a
local user
      will be presented with a tailored debugging screen that includes
exception
      message, stack trace, request parameters, session contents, and the
      half-finished response.

    Learn more in link:classes/ActionController/Rescue.html


* Scaffolding for Action Record model objects

      require 'account' # must be an Active Record class
      class AccountController < AccountController::Base
        scaffolding :account
      end

      The AccountController now has the full CRUD range of actions and
default
      templates: list, show, destroy, new, create, edit, update

    Learn more in
link:classes/ActionController/Scaffolding/ClassMethods.html


* Form building for Active Record model objects

      The post object has a title (varchar), content (text), and
      written_on (date)

      <%= form "post" %>

      ...will generate something like (the selects will have more options
of
      course):

      <form action="create" method="POST">
        <p>
          <b>Title:</b><br/>
          <input type="text" name="post[title]" value="<%= @post.title
%>" />
        </p>
        <p>
          <b>Content:</b><br/>
          <textarea name="post[content]"><%= @post.title %></textarea>
        </p>
        <p>
          <b>Written on:</b><br/>
          <select 
name='post[written_on(3i)]'><option>18</option></select>
          <select name='post[written_on(2i)]'><option
value='7'>July</option></select>
          <select
name='post[written_on(1i)]'><option>2004</option></select>
        </p>

        <input type="submit" value="Create">
      </form>

      This form generates a @params["post"] array that can be used
directly in a save action:

      class WeblogController < ActionController::Base
        def save
          post = Post.create(@params["post"])
          redirect_to :action => "display", :path_params => { "id" =>
post.id }
        end
      end

    Learn more in link:classes/ActionView/Helpers/ActiveRecordHelper.html


* Automated mapping of URLs to controller/action pairs through Apache's
    mod_rewrite

      Requesting /blog/display/5 will call BlogController#display and
      make 5 available as an instance variable through @params["id"]


* Runs on top of CGI, FCGI, and mod_ruby

      See the address_book_controller example for all three forms

--
David Heinemeier Hansson,
http://www.rubyonrails.org/  -- Web-application framework for Ruby
http://www.instiki.org/      -- A No-Step-Three Wiki in Ruby
http://www.basecamphq.com/   -- Web-based Project Management
http://www.loudthinking.com/ -- Broadcasting Brain
http://www.nextangle.com/    -- Development & Consulting Services