Meta Bates

This post has moved to the wiki @ http://wiki.mackframework.com/index.php/Blog%20Tutorial

This is a pretty cool release. First off Thin has been updated to 0.8.0, a rather nice, stable release. ERB has been replaced with Erubis to give a significant improvement in speed, which, after all is one of Mack’s most important traits. 

There’s been a general overhaul of the generators included with Mack. Mostly, cleaning them up. With that said things like the scaffold, model, and migration generators have been updated to do what a lot of people have been asking for, that is take a ‘cols’ parameter and build out the generated code corrrectly. This really makes life, very, very simple.

There will be a re-written ‘blog’ tutorial coming out soon to make use of this, as well as migration support that’s now part of Mack.

Very exciting stuff! Enjoy!

Changelog:

• Mack now uses Erubis, http://www.kuwata-lab.com/erubis/, for it’s rendering engine instead of ERB. This makes Mack even faster now! Yippie!
• Added rake generate:model name=<model_name> (optional: cols=<col_1>:<col_1_type>,<col_2>:<col_2_type>) This will also create a migration for you.
• Updated rake generate:migration name=<model_name> (optional: cols=<col_1>:<col_1_type>,<col_2>:<col_2_type>) This will create the proper table migration for you.
• Updated rake generate:scaffold to use the ModelGenerator now.
• ScaffoldGenerator now create input fields based on the type of columns, if any, passed in.
• Overall general refactoring of the generator classes.
• Fixed a bug with request logging not, well, logging.
• gem: erubis 2.5.0
• gem: thin 0.8.0

It dawned on me today as I released 0.4.1 that’s it has been one month since the first release, 0.0.4. What a month it’s been! When 0.0.4 got released I hadn’t been working on Mack for more than a few weeks. So really, Mack has been going for about six weeks now. It’s funny to think how far the code has progressed, how many features have been developed, and most importantly, how much attention it’s received.

Firsts:

• First Bug: Matt Todd found the first bug with a Mack. It was a simple bug with convert_security_of_methods the second parameter wasn’t being used. Matt has since become a good friend of Mack, and has a couple of other firsts on this list.
• First Blog Comment: Mr. Eel questioning the validatey of some rough DataMapper vs. ActiveRecord numbers I posted.
• First Link to Mack: Matt Todd gets his second ‘first’ of this list.
• First ‘Demo’ Request: Gregg Pollack from RailsEnvy.com requested a demo app so he could feature Mack on the RailsEnvy.com podcast.
• First Podcast: I think this one is fairly obvious, but it goes to the RailsEnvy.com guys. Thanks for the press!
• First Speaking Request: Tom Dyer/Boston Ruby Users Group. I’ll be speaking May 13th on the joys of Mack.
• First Request to Contribute: Arun Agrawal.
• First Tech Support Request: Brian Dunbar. He had some trouble running the demo app. Turns out it was a bad require in the cachetastic gem, that I subsequently fixed.
• First ‘Watcher’ on GitHub.com: Once again, Mr. Matt Todd! Gotta love the Matt.
• First Fork on GitHub.com: Kabari Hendrick. Based out of Chicago, http://www.threedozen.com/, I’m excited to see what he does with his fork.

Wow! That’s a lot of firsts for a first month. Here’s a list of some of the features that have been released in that time:

• Distributed Routes!
• Better testing support
• Built-in encryption/decryption
• XML support
• A Generator framework
• ‘Scaffold’ generator
• Plugin support
• Server-side redirects
• Inflection
• Render url
• Extensible rendering system
• ‘Format’ driven content

That’s just a few things that have gone in there. That’s not to mention refactoring, documentation, demo apps, etc…

I’d like to this time to say thank you to everyone on the ‘firsts’ lists. I would like to thank everyone else who’s shown interest, commented, wrote about, or even just thought of Mack. Every comment on the site, every email I get, every blog link I see fills me with great happiness and makes me think that I’m on to something here.

I truly feel that there is a void for a Ruby web framework that deals with distributed, portal-like applications, and that’s where Mack is headed. That’s what makes Mack different from Rails or Merb or Ramaze or Sinatra or any other framework out there.

What’s on the horizon for Mack? A lot. I’m going to be speaking at the Boston Ruby Users Group on May 13th. Of course, I’ll be showing off Mack, so if you’re in town, I would recommend coming on down. Details on that as we get closer to the event. You can expect more app to app communication, more generators, more ORM support, more testing support, page caching, ‘portlets’, and much much more!

Once again, thanks to everyone for their support. I’m looking forward to see what the future holds.

Ok, because every good framework should tell you how to create a blog, why should Mack be any different? Let’s start off with the basics. Is Mack installed? If not, here’s how:

$ sudo gem install mack

Great! Before we move on, make sure that the gem you installed is at LEAST version 0.1.0, otherwise, you’re not going to get very far in this tutorial. Now, let’s move on. Now let’s generate our kick ass new blog, and since we’re going to need some sort of database support for our blog, we’ll configure it to use DataMapper. If you don’t have DataMapper installed, please head over to http://datamapper.org to find out how to install it. Mack has support for ActiveRecord as well, but it’s just easier to get DataMapper going because you don’t have to deal with migrations.

$ mack my_kick_ass_blog -o data_mapper
$ cd my_kick_ass_blog

That should’ve created a whole bunch of files and folders for your blog. Now let’s generate some scaffold code for our blog:

$ rake generate:scaffold name=posts

That should’ve created even more files for you. One of those files is app/models/post.rb, let’s open that up, so we can edit it for DataMapper.

Edit the file so it looks something like this:

class Post < DataMapper::Base
  property :title, :string
  property :email, :string
  property :body, :text
  property :created_at, :datetime
  property :updated_at, :datetime

  validates_presence_of :title
  validates_presence_of :body
  validates_presence_of :email
end

Now, I’m not going to go into detail as to what that’s doing, that’s for the guys at DataMapper to explain. Before we move on to the next step, you’ll probably want to crack open config/database.yml and edit it so it the paths to your database are correct, you’ll probably also want to go to your database system and make sure that the database name you configured in your config/database.yml is created, otherwise this will be a very short trip. I’ll wait while you do that. Finished, great! Let’s move on.

We need to now open a Mack console so we can create the tables needed for our blog.

$ rake console
$ Post.table.create!
$ exit

Ok, we should now have a posts table in our new database. Isn’t life wonderful? We’re so close to showing the world how wonderful we are as developers.

Now let’s edit our views, so they look something like this:

app/views/posts/index.html.erb:

<h1>Listing posts</h1>

<table>
  <tr>
    <th>Title</th>
    <th>Body</th>
    <th>Email</th>
  </tr>

<% for post in @posts %>
  <tr>
    <td><%=post.title %></td>
    <td><%=post.body %></td>
    <td><%=post.email %></td>
    <td><%= link_to("Show", posts_show_url(:id => post.id)) %></td>
    <td><%= link_to("Edit", posts_edit_url(:id => post.id)) %></td>
    <td><%= link_to("Delete", posts_delete_url(:id => post.id), :method => :delete, :confirm => "Are you sure?") %></td>
  </tr>
<% end %>
</table>

<br />

<%= link_to("New Post", posts_new_url) %>

app/views/posts/edit.html.erb:

<h1>Edit post</h1>

<%= error_messages_for :post %>

<form action="<%= posts_update_url(:id => @post.id) %>" class="edit_post" id="edit_post" method="post">
  <input type="hidden" name="_method" value="put">
  <p>
    <b>Title</b><br />
    <input id="post_title" name="post[title]" size="30" type="text" value="<%= @post.title %>" />
  </p>

  <p>
    <b>Body</b><br />
    <textarea id="post_body" name="post[body]"><%= @post.body %></textarea>
  </p>

  <p>
    <b>Email</b><br />
    <input id="post_email" name="post[email]" size="30" type="text" value="<%= @post.email %>" />
  </p>

  <p>
    <input id="post_submit" name="commit" type="submit" value="Create" />
  </p>
</form>

<%= link_to("Back", posts_index_url) %>

app/views/posts/show.html.erb:

<p>
  <b>Title:</b>
  <%= @post.title %>
</p>

<p>
  <b>Body:</b>
  <%= @post.body %>
</p>

<p>
  <b>Email:</b>
  <%= @post.email %>
</p>

<p>
  <b>Created at:</b>
  <%= @post.created_at %>
</p>

<p>
  <b>Updated at:</b>
  <%= @post.updated_at %>
</p>

<%= link_to("Edit", posts_edit_url(:id => @post.id)) %> |
<%= link_to("Back", posts_index_url) %>

app/views/posts/new.html.erb:

<h1>New post</h1>

<%= error_messages_for :post %>

<form action="<%= posts_create_url %>" class="new_post" id="new_post" method="post">
  <p>
    <b>Title</b><br />
    <input id="post_title" name="post[title]" size="30" type="text" value="<%= @post.title %>" />
  </p>

  <p>
    <b>Body</b><br />
    <textarea id="post_body" name="post[body]"><%= @post.body %></textarea>
  </p>

  <p>
    <b>Email</b><br />
    <input id="post_email" name="post[email]" size="30" type="text" value="<%= @post.email %>" />
  </p>

  <p>
    <input id="post_submit" name="commit" type="submit" value="Create" />
  </p>
</form>

<%= link_to("Back", posts_index_url) %>

Ok, so now we’ve created our forms, and setup our index page. Let’s actually go to the site and see it all works!

First we need to start the server:

$ rake server

Now let’s head on over to http://localhost:3000/posts and see what we’ve got. You should see a page that looks something like this:

Now let’s click on that ‘New Post’ link and fill out the form:

Now, let’s hit that wonderful ‘Create’ button and see what happens!

Congrats! You just created your first blog post! Now let’s head back to http://localhost:3000/posts and see what we’ve got.

Wonderful! Now all that’s left to do is to set our home page to our posts index page. Let’s open up our config/routes.rb and edit the following line:

r.home_page "/", :controller => :default, :action => :index

so that it’s now:

r.home_page "/", :controller => :posts, :action => :index

Now all you have to do is to restart your server and Bob’s your uncle when you hit http://localhost:3000 again you should your fantastic posts index page.

This concludes our brief introductory tutorial on getting going on Mack. Obviously Mack does a lot more, and I highly encourage you to read the RDoc to find out more about what it can do.

Enjoy.

Rejoice! Yet another new release. Please be patient for the gem mirrors to pick it up.

Changelog:

• Added an inflections system. The default inflections are from Jeremy McAnally’s great Rails plugin, acts_as_good_speeler. Thanks Jeremy! http://www.jeremymcanally.com/

• Added a to_params method to Hash to help with testing.

• Added rake generate:scaffold task.