USINGMAC.com - Home

Safari - Exporting Bookmarks into HTML File

2008-05-12T14:25:00Z

There are 2 ways to export Safari Bookmarks plist file into HTML file, the first one is the geeky way and the other is using third party application. Let's see how it can be done.

The Geeky Way

Open your Terminal and execute this command line, which will add Debug menu to Safari :

defaults write com.apple.Safari IncludeDebugMenu 1

After relaunching Safari, you now can choose File ▸ Export Bookmarks... And the rest of the steps should be obvious.

Safari Bookmarks Extractor

Go to Arcadia Design homepage and download Safari Bookmarks Extractor (144KB). After that, the application clearly explains how to export Safari bookmarks.

Top 8 Mac Screensavers

2008-05-11T14:38:00Z

Hyperspace and Helios

The screensaver is nice, giving you the image of ultra high speed. However, They are quite heavy to be processed. They can be downloaded here for Hyperspace and here for Helios.

LotsaGlass

It can transform itself and it has many unique shapes. I really hope I can have a glass like this for real. You can get the screensaver here.

Time Machine

As a clone of Time Machine animation, this screensaver gets many attention also. Download it here and drop it to your screensaver pane.

Fenetres Volantes

Let's fly! The screensaver can be downloaded here.

LotsaWater

If you haven't ever seen your Mac drowned in water, you can try this screensaver out. It gives the effect of your whole display being drowned! You can download it here.

Flurry

And still, Flurry is the best screensaver for Mac OS X.

Finder - Plain List View

2008-05-10T12:32:00Z

Activate Plain Finder

If you dislike the blue and white stripes on your Finder list view, you can use following line of Terminal command to make the background display plain white.

defaults write com.apple.finder FXListViewStripes -bool FALSE
killall Finder

Revert Back

Maybe you want to revert back to original display of your Finder list, you can use following Terminal command :

defaults write com.apple.finder FXListViewStripes -bool TRUE
killall Finder

And you will get the previous blue and white stripes Finder list.

Spotlight - Indexing

2008-05-09T07:45:00Z

Prevent Spotlight Indexing

Sometimes you don't want your Spotlight to index some parts of your Mac, e.g. your backup drive. If that's the case, you can set up your Spotlight to prevent searching in several locations. This setting can be performed under System Preferences ▸ Spotlight ▸ Privacy. Adding that particular folder into the pane provided will result in Spotlight stop indexing that folder.

ReIndex Spotlight

If you want Spotlight to reindex a certain volume, you can use following terminal line :

sudo mdutil -E -p "/Volumes/Mac HD"

Note : The volume name Mac HD is just for example, you should change it accordingly to the drive you want Spotlight to reindex.

Finder: Checking Total Size of Files

2008-05-04T14:43:00Z

When you want to check the size of a single file, highlighting the file followed by pressing I (Get Info) is enough to extract out the file size.

However, if you do the same when you highlight multiple files, a lot of File Info Pane will appear. In order to pretend this to happen and you only get a single pane that display the total size of selected files, you can use I (Show Inspector).

Finder - Icons on Toolbar

2008-05-02T15:48:00Z

Do you want to use your Finder's toolbar as your additional Dock?

Putting Icons on Finder's Toolbar

It's really easy to put those applications' icon onto your Finder's toolbar, you only need to Drag icons one by one to your Finder's toolbar, Hold on for a second or two until the square brackets appear and Release it.

Taking Off from Toolbar

When you're getting bored with those icons on your Finder's toolbar, you can easily take them off by Pressing followed by Dragging the icon off the toolbar. It's that easy.

Apple Mail - Setting Gmail Account

2008-04-30T15:51:00Z

I found this tutorial from Google really useful when you want to create new Gmail account for your Apple Mail application.

Step 1. Mail ▸ Preferences...

Step 2. Accounts ▸ Add New Account

Fill in your name, full Gmail address and your Gmail password. It will look like image below.

Step 3. Incoming Mail Server

Select IMAP as your account type and use imap.gmail.com as your incoming mail server.

Step 4. Outgoing Mail Server

Use smtp.gmail.com as your outgoing mail server and use your correct Gmail address and password for authentication.

Step 5. Summary

Read the summary and click on create to confirm your creating new account.

Result

Now you can see your new Gmail account has been added to your Apple Mail Accounts.

Safari and Firefox - Quick Google Search

2008-04-29T13:42:00Z

Usually, what will you do when you want to start new search with Google search bar on the top-right corner of your web browser? There are three ways to do that.

Type 1. Google Homepage

This is the least advanced way. However, most of my friends still use this way. First, you open new tab (shortcut : T), followed by typing in the url address "www.google.com", filling in the search term and Google will return you the result.

The advantage of using this way is that you can see Google homepage which in special occasion, the logo is changed.

Type 2. New Tab and Search Bar

In this way, you will open a new tab (shortcut : T), move cursor to search box (shortcut : L or F for Safari and K for Firefox), type the search term and Google will bring you to the result page for your search.

Type 3. Search Bar and Open Search in New Tab

Fortunately, you don't really need to open new tab before you want to perform new search with Google. You can jump quickly to the search bar with the shortcut provided (as exposed before), type in your search term and then open url in new tab (shortcut : for Safari and for Firefox). In return, you will have new tab opened with the search result from Google.

Safari - Easy Private Browsing Toggling

2008-04-28T10:23:00Z

It's quite surprising that when I open my MacBook today, I saw a globe instead of Apple logo. Anyone knows why?

Safari Private Browsing

Ok. Let's talk about Private Browsing of Safari. We all know that with private browsing, whatever we browse won't come out at the History section of our Safari browser. It's quite a nice feature that Safari has.

However, it's quite unfortunate that the shortcut to activate/deactivate private browsing isn't available by default. Here is a way to assign a new shortcut to activate/deactivate private browsing.

Keyboard & Mouse System Preferences

Maybe you've already known that whenever you want to customize new keyboard shortcuts, you need to go into Keyboard & Mouse Preference Panes. After you've been inside this pane, go to the Keyboard Shortcuts section.

Add New Shortcuts

You can see all the lists of available keyboard shortcuts here. Scroll down to the bottom of the list. If you've already assigned customized keyboard shortcuts for your Safari web browser before, you can see the label Safari there.

Highlight that line (Safari) and click on the "+" button near the left bottom corner of the shortcuts' list. You should do new shortcut assignment two times and fill the pop-up pane like what are shown below.

Restart Safari and Try New Shortcut

Now, you've finished assigning new shortcut to your Safari. You need to restart your Safari for the changes to take effect. When you press Fn++P, private browsing will be activated. If you press it for the second time, your Safari private browsing will be deactivated. Is it useful?

A Little Side Effect

You will see two Private Browsing options when you click on ▸ Safari.

Add spacers to Leopard OS X

2008-04-10T00:05:00Z

In Terminal.app, execute the command for number of times you want to create spacer.

defaults write com.apple.dock persistent-apps -array-add '{"tile-type"="spacer-tile";}'

Then restart Dock. execute this command in Terminal.

killall Dock

Spacer can move with drag, can remove by context menu or drag outside. Another alternative, you also can download divider docks from Dock Dividers.

Display - Hot Corners

2008-03-27T05:14:00Z

In Tiger, Expose is very essential feature that most of Mac user need. Upgrading to Leopard, you also get the access to more Spaces. To use these great features easily, you could use Hot Corners.

Hot Corners

Hot corners help you activate one of those features whenever you move your mouse to the corner of the screen. And you can easily set up your hot corners. How to set up hot corners?

Setting Hot Corners

First of all, go inside ▸ System Preferences... Go to your search box, the one with magnifier at the left, and type in "hot corner" to look for this feature. You will see 2 items highlighted. Choosing either one has the same result.

Option 1. Via Desktop & Screen Saver Preferences Pane

If you choose to set up your hot corners using through this pane, you can do the following :

Enter Desktop & Screen Saver Preferences Pane
Click on the button labelled "Hot Corners"
Additional menu will drop down. Here you can set up to four functions, each to one corner
Confirm your changes by clicking the "OK" button

Option 2. Via Expose and Spaces Preferences Pane

Using this pane is faster than the previous one. Unlike the previous one, you don't need to click on the button; Here you can directly assign the function of each corners.

Tips. Avoiding Accidental Triggering

You will be likely to encounter this issue using Hot Corners; You could accidentally move your mouse to the corner and activate the function assigned to that particular corner. Combining with modifier keys will help you solve this problem.

Screensaver - Another Point of View

2008-03-18T15:59:00Z

Do you remember the most famous Mac Screensaver,
which is named Flurry?

With a little reflection from your Mac keyboard,
you can make it beautifully shines.

<object height="350" width="425"> <param name="movie" value="http://www.youtube.com/v/AKa8WjTmJ5k"> </param> <embed type="application/x-shockwave-flash" src="http://www.youtube.com/v/AKa8WjTmJ5k" height="350" width="425"> </embed> </object>

Is it nice?

Preview Tutorial - Reading PDF Files

2008-03-16T15:41:00Z

Brief Introduction

Somehow I feel it's quite difficult to read through many pages of PDF using my small display of MacBook. Fortunately, I come out with several ideas to improve the readability of reading PDF files with Preview which is our Mac default application to view PDF files.

Setting Default Application

Perhaps you haven't set up your default opening application for PDF file to Preview, you can do the following steps :

Highlight one of your collection of PDF Files
Right click on it to show up the contextual menu
Mouse over on Open With with modifier keys Option() pressed. You should notice that the name is now changed to Always Open With
Choose and Click on Preview
Now, you've done setting up Preview as your default opening PDF Files as well as opening that highlighted file with Preview

Adjusting Display Size

For big monitor's owner, the view area wouldn't be much of trouble for you that you can easily right-click on the display area and choose Automatically Resize. This will make your previewed page automatically zoomed to fit the entire view pane with its height and width proportional to the initial size.

Because the entire page is displayed on the view pane, you can easily jump to next page using your mouse-scroll or pressing Down-Arrow key.

Problem arises when you need to view your long PDF File using small display of your MacBook. Suitable view will result it your Preview to have scroll bar on the right side of its view pane which causes the mouse-scroll and down-arrow key cannot be used to change to next page.

Luckily, you can use Right-Arrow key instead. This can be used to switch to next page successfully. Note that using mouse-scroll or Down-Arrow can also change page but you're required to hit the end of page first.

Hopefully, now you can get the convenient display and navigate easily. You can use +/- to zoom in/out followed by pressing the Zoom button (green button at top left corner of the pane) to adjust your view.

Jump to Specific Page

When you have hundreds pages of file, it will be really tedious to scroll down page by page to let say you want to reach page 145. You can use Go to Page.. G which is located under ▸ Go ▸ Go to Page.. Putting in the page number you want to look for and you'll be taken to the specified page.

Developing Rails Application on Mac OS X Leopard

2008-03-15T06:45:00Z

With Ruby on Rails you can build powerful and dynamic web sites. Read this article to learn how to develop your application using Xcode 3.0 and the tools that come pre-installed in Leopard.

Ruby on Rails is a popular and powerful open source web framework for rapidly creating high-quality web applications. Rails is thriving on Mac OS X, and Leopard comes pre-installed with Ruby, Rails, Mongrel, Capistrano, Subversion, and other tools that help to streamline the development and deployment of Rails applications. We will use the Organizer feature of XCode 3.0 to demo the step of the development.

This article gives you a full tour of Ruby on Rails 2.0 on Mac OS X Leopard and building a web application using the latest Rails features with Xcode 3.0.

Ruby, Rails, and Leopard

In Leopard, Ruby and Rails are pre-installed abundle with of other useful RubyGems. By default, you get Ruby version 1.8.6 and Rails version 1.2.6, the latest stable releases at the time Leopard shipped. Ruby releases are few and far between (it's still at 1.8.6), but Rails has frequent new releases. In fact, the application we'll build requires Rails 2.0.2. The good news is it's easy to upgrade Rails and RubyGems. Make sure your system is up to date now by running these commands:

 sudo gem update --system
 sudo gem install rails
 sudo gem update rake
 sudo gem update sqlite3-ruby

Do the command below too, to check your version of ruby and rails:

	ruby -v
	ruby 1.8.6 (2007-09-24 patchlevel 111) [i686-darwin9.1.0]
	
	rails -v
	Rails 2.0.2

The first command updates the RubyGems system itself, which is required by the latest version of Rails. The second command updates Rails-specific gems and installs any new components (specifically Active Resource). The third command updates Rake, the make-like build tool used by Rails. Finally, the last command updates the Ruby bindings for the SQLite3 database. Running all these commands may take a while. When it's finished, you can list all the installed gems by typing

 gem list --local

If you've used Ruby before, you may be interested to know where the Ruby gems live in Leopard. The answer is in two places:

/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8 
/Library/Ruby/Gems/1.8

The /System repository is where all the pre-installed gems live, while the /Library repository is empty by default. When you install new gems, they'll end up in the /Library repository. Thankfully, it's all transparent.

Creating a New Rails Application

Note: This tutorial uses Rails version 2.0.2. With future Rails updates, some of the functionality described in this article may change.

Let's say, for example, that we have a club that organizes fund-raising events. When we put on an event we incur expenses from vendors who provide goods and services. Our club operates on a fairly tight budget, so we need to make sure expenses are in line with the budget for each event. The old paper and pencil system broke down last month and we've decided to replace it with an online expense tracking application that everyone can share.

First we need to create the application. All Rails applications have a consistent directory structure so that Rails can find stuff without needing to be told where to look. In a directory of your choosing (e.g., your home directory), create a skeleton application directory structure and a set of files for our expenses application by typing

 rails expenses

That command generates a number of directories and files in an expenses directory. We'll be editing various files as we go, and to streamline your development workflow you'll want quick access to frequently used files. Xcode 3.0 in Leopard has an Organizer feature that makes it easy to navigate around Rails projects. You don't even need to create a new Xcode project.

Follow these steps to open the Rails application in the Organizer:

Launch Xcode and choose "Window > Organizer". An empty Organizer window appears.
Drag your expenses directory from a Finder window into the Organizer window.
Click the disclosure triangle next to the top-level expenses directory to display its contents.
Drill down into the app/controllers directory and select the application.rb file.
Display the text editor pane by clicking the rectangle icon in the bottom-left corner of the Organizer.

In the Organizer window, shown in Figure 1, you should see the files and directories that the rails command created. You'll notice in the Organizer that you have familiar Xcode editing features such as syntax coloring, code folding, line numbers, method shortcuts, and so on.

Figure 1: Xcode 3.0 Organizer showing the Rails application directory structure

At this point, we could go ahead and fire up our expenses application from a Terminal command line using the script/server command. However, in addition to giving you a central place to edit files, the Xcode Organizer also lets you assign actions to folders. So rather than running the Rails application in a separate Terminal window, we'll assign an action to run it straight from the Organizer.

Follow these steps to create a new Organizer Action to run the Rails application:

Select the top-level expenses folder.
Click and hold the Run toolbar item until a pop-up menu appears. Choose "Edit Actions..." and you should see the Action Editor as shown in Figure 2.

Figure 2: Xcode 3.0 Organizer Action Editor

The list on the left side of the Action Editor displays actions associated with the Run toolbar item, along with their with optional shortcut keys. On the right side is a drop-down directory specifier and a script editor.
Add a new Shell Script Action using the add button (+) in the bottom-left corner of the Organizer. Name the action "start server" by double-clicking on the default name "Shell Script".
Set the directory to "Top Level Organizer Item". This indicates that the action's command should be run from the top-level folder (expenses), regardless of the folder that's currently selected when the action is run.
Change the command to "script/server" and clear out the arguments.

The Action Editor should now look like the one shown in Figure 3.

Figure 3: Adding a new Organizer Action
Click "OK" to save the new action.
Back in the Organizer window, select the expenses folder, then click and hold the Run toolbar item. When the pop-up menu appears, choose the "start server" action. (Or just click the Run button and it'll run that action since there's only one assigned action.)

A Debugger window opens and starts the server with output similiar to the output shown in Figure 4.

Figure 4: Running an Organizer Action
Now point Safari at http://localhost:3000. You should see a web page welcoming you aboard Rails.

So far, we've stood up a brand new application and we're organized, but it doesn't help our fund-raising campaign. Let's fix that.

Jump-Starting the Application

Now we're ready to put some meat on the bones of the skeleton directory structure. For starters, we need a web interface for creating some events in the database. An event is simply a name and a budgeted amount. The fastest way to put up a web interface backed by a database is by using what Rails calls scaffolding. Scaffolding is the initial supporting code that handles the basic create, read, update, and delete (CRUD) operations of any database-backed web application.

Open a Terminal window, then change directory to the expenses directory and create the event scaffolding by typing

 script/generate scaffold event name:string budget:decimal

This single command generates all the Ruby code we need to start administering events:

Model: An Event model class in the app/models/event.rb file
View: View template files in the app/views/events directory for listing, showing, creating, and editing events
Controller: An EventsController class in the app/controllers/expenses_controller.rb file
Database Migration: A CreateEvents class in the db/migrate/001_create_events.rb file that when run creates an events database table with three columns: id, name, and budget

We'll look at these files in more detail shortly. All we need to do now is apply the database migration to create the events database table so we can start creating events. Rails applications use Rake (Ruby's equivalent of Make) to automate recurring tasks such as applying migrations. We could run rake db:migrate from a Terminal command line, but again the Organizer makes this easier. All the Rake tasks are already available as pre-configured actions.

Click and hold the Action toolbar item, then choose the "db:migrate" action (the first one). A window opens showing the results of applying the migration, as shown in Figure 5.

Figure 5: Applying the events database migration

Let's see how close scaffolding gets us to a web interface for administering events. Point Safari at http://localhost:3000/events. You should see a web page that lets you create new events.

Go ahead: create an event and the new event will show up in the event listing. From there you can show, edit, or delete the event. Figure 6 shows example events for our fund-raising campaign.

Figure 6: Using scaffolding to administer events

That takes care of event management. Now let's repeat the cycle to put up a web interface for administering vendors. Generate the vendor scaffolding by typing

 script/generate scaffold vendor name:string email:string

This command generates all the supporting code for a vendor web interface, including a database migration in the db/migrate/002_create_vendors.rb file.

Apply the new migration to update the database schema to include the vendors table by choosing the "db:migrate" action from the Action toolbar item. The results are shown in Figure 7.

Figure 7: Applying the vendors database migration

Then point Safari at http://localhost:3000/vendors. You should see a web page that lets you create new vendors.

To recap: In a very short amount of time, and with no explicit configuration, we've created a database-backed web application to CRUD (the verb form) events and vendors. It won't win any web design awards, but it's functional and gives us a jump-start on our application.

How It Works

Looking at the code generated by the script/generate scaffold command is a great way to learn how Rails applications work. After all, the templates used by the generator were written by the Rails core team. And as we'll see a bit later, scaffold-generated code serves merely as an exemplar that should be tweaked as necessary for your application.

Let's follow a request through the request/response cycle, looking inside the scaffold-generated code as we go to see how all the components work together. Figure 8 shows the MVC components in play for events, and their file equivalents.

Figure 8: MVC components and their files

RESTful Conventions

The speed at which we were able to create a fully-functioning web application can be credited in large part to conventions. Rails relies heavily on conventions to eliminate most configuration, thus making web developers a lot happier.

Take, for example, the "Show" hyperlink for an event. In the app/views/events/index.html.erb template, the hyperlink is generated using

<%= link_to 'Show', event %>

That line of code generates the following HTML, for example:

<a href="/events/1">Show</a>

When this hyperlink is clicked in Safari, it ends up executing Ruby code inside the Rails application. But how does Rails know how to route an incoming URL to the appropriate code that handles the request? The answer: conventions.

It turns out that the HTTP protocol already has conventions for interacting with resources on the web via a simple set of verbs: GET, POST, PUT, DELETE, etc. With every HTTP request comes one of these verbs. The URL identifies the resource (the noun, if you will). For example, clicking the http://localhost:3000/events/1 link issues a GET request for the event living at that web address.

This resource-oriented approach to web design is an example of the REST architectural style, and Rails has whole-heartedly embraced it. Now, REST is a relatively complex (and academic) topic that's beyond the scope of this article. Thankfully you don't have to be a REST expert to use Rails. You just need to tell Rails which resources should be accessible via the RESTful conventions. Rails then takes care of routing incoming HTTP verbs and URLs to those resources.

When we ran the scaffold generator for events, for example, Rails assumed that events are resources we want to expose via RESTful conventions. The same is true for vendors. So if you look in the config/routes.rb file you'll see that the following lines were automatically added:

map.resources :events 
map.resources :vendors

Those two lines of code dynamically add routes for accessing our events and vendors according to the RESTful conventions. To see all the routes, choose the "routes" action from the Action toolbar item.

Let's look at just a few of the routes in the list you'll see to get a glimpse of what's going on behind the scenes:

events GET  /events {:controller => "events", :action => "index"} 
       POST /events {:controller => "events", :action => "create"} 
  
event  GET /events/:id {:controller => "events", :action => "show"} 
       PUT /events/:id {:controller => "events", :action => "update"}

In a nutshell, the map.resources line generates routes into our application using both the incoming HTTP verb and URL. For example, to list all the events we'd send in the URL /events. The exact same incoming URL is used to create a new event. The only difference is the HTTP verb that is used: GET is a read-only operation that lists the events and POST is a write operation that creates a new event. To show or update an existing event, the URL needs to include the event id (primary key), for example /events/1. Again, the URL is the same, but the HTTP verb is different: GET fetches the event and PUT updates the event.

Controllers

Now let's follow the request back into scaffold-generated MVC code. When Rails receives a GET request for the /events/1 resource, for example, it invokes the show method (called an action) of the EventsController. That action is found in the app/controllers/events_controller.rb file.

class EventsController < ApplicationController
  
  def show
    @event = Event.find(params[:id])
    
    respond_to do |format|
      format.html # renders show.html.erb
      format.xml  { render :xml => @event }
    end
  end
  
  # plus other action methods for listing, creating, 
  # updating, and deleting events
end

The show action uses the event id supplied in params[:id] (1, in this case) to find a matching event in the events database table. It then populates an Event model object with the values corresponding to that database table row. The resulting Event model object is assigned to the @event instance variable. (Ruby identifies instance variables as variables starting with an @ symbol.)

Models

The Event model class itself lives in the app/models/event.rb file.

class Event < ActiveRecord::Base
end

At first glance, this class appears to do nothing, but in fact it already has a lot of functionality inherited through its ActiveRecord::Base parent class. ActiveRecord is a component of Rails that, among other things, uses reflection and naming conventions to transparently map relational database tables into models. By convention, the Event model encapsulates access to the events table in our database. An instance of an Event model represents a row in the events table, with each table column mapping to an attribute of the Event instance.

For example, without any additional configuration or code, inside of the show action we could get the name of the event using:

@event.name

Database Migrations

Now you may be wondering which database Rails is using and how it got connected. When we created the application, a config/database.yml file was generated. In that file you'll notice that Rails has pre-configured three database connections—development, test, and production—that correspond to three runtime environments.

We're doing development now (the default environment), so have a look at that particular section of the config/database.yml file.

development:
  adapter: sqlite3
  database: db/development.sqlite3
  timeout: 5000

Rails configures a SQLite3 database by default, which is quite handy given that SQLite3 is already installed on Leopard. When it comes time to deploy this application, we'll switch over to a MySQL database running on Leopard Server.

When we ran the first database migration to create the events table, the db/development.sqlite3 database was automatically created. Here's what the db/migrate/001_create_events.rb file looks like:

class CreateEvents < ActiveRecord::Migration
  def self.up
    create_table :events do |t|
      t.string :name
      t.decimal :budget

      t.timestamps
    end
  end

  def self.down
    drop_table :events
  end
end

Migrations give us a way to evolve our database schema and data over time in a repeatable, automated way. Each migration defines two class-level methods: up and down. The up method moves the migration "forward", in this case by creating the events table and its columns. Note that create_table will implicitly create a primary key column called id by default.

The down method rolls the migration "backward", in this case by dropping the events table. That is, migrations are reversible. For example, if you wanted to drop the events table, you'd type 'rake db:rollback'.

Views

Back in the show action, we've fetched the event from the database and now it's time to show it. The respond_to block decides how to render the event depending on the format requested by the client. Since we're using Safari as the client (and we haven't explicitely specified a format), the format will be HTML. So in this case, the show action renders the template found in the app/views/events/show.html.erb file.

<p>
  <b>Name:</b>
  <%= h @event.name %>
</p>

<p>

  <b>Budget:</b>
  <%= h @event.budget %>
</p>

<%= link_to 'Edit', edit_event_path(@event) %> |
<%= link_to 'Back', events_path %>

Rails view templates are a mix of HTML and Ruby code. Any expression between <%= and %> is evaluated as Ruby code and the result is substituted back into the response. Notice that the show template has access to the @event instance variable that was created in the show action of the EventsController. Using the @event variable, the show template simply outputs the value of each event attribute with its associated column name.

The template then generates hyperlinks to the edit and index actions using the link_to helper. The edit_event_path and events_path methods were generated by the map.resources :events declaration we saw previously. They create URLs according to the RESTful conventions that route back into the application.

At this point we've followed one HTTP request through the scaffold-generated code to generate an HTML page as the response. Now let's start adding some code of our own.

Validating Models

You may have noticed that the scaffold-generated web form used to create and edit events will let you enter anything in the fields, and even let you leave required fields blank. That's no good—we only want valid data in our database.

Maintaining the consistency of the application's data is a model's job. Rails includes a rich set of built-in model validations and it's easy to write your own, as well. So let's add some model validations to ensure an event has a name and a valid budget amount.

Update the app/models/event.rb file as follows:

class Event < ActiveRecord::Base
  validates_presence_of :name
  validates_numericality_of :budget, :greater_than => 0.0
end

Now try to create an event with a blank name or invalid budget amount. You should see something similar to the web form shown in Figure 9.

Figure 9: Model validations at work

Linking Models Together

Administering events and vendors is a good start, but we're still missing the ability to track expenditures. An expense is simply an amount charged by a vendor for an event. In database terms that means an expense needs to have foreign keys pointing to its event and vendor. In other words, an expense joins together an event and a vendor. The database schema we're aiming for is shown in Figure 10.

Figure 10: Many-to-many association database schema

Just like event and vendor, we want an expense to be a resource. The only difference is we don't need a full scaffold-generated web interface for expenses. Instead, we're going to record expenses using our existing events web interface. However, we still need a migration, a model, and a controller for expenses.

Generate a new expense resource by typing:

 script/generate resource expense event_id:integer vendor_id:integer amount:decimal

Naming is important here. Rails assumes that the event_id foreign key column references the id column of the events table, and likewise vendor_id references the id column of the vendors table. It's yet another example of how Rails uses naming conventions to keep external configuration at a minimum. (You can always override the default behavior.)

Then apply the migration that was generated in the db/migrate/003_create_expenses.rb file to create the expenses database table by choosing the "db:migrate" action from the Action toolbar item. The results are shown in Figure 11:

Figure 11: Applying the expenses database migration

At this point we have an expenses database table with foreign key references to the events and vendors tables. That's one side of the coin. Rails still doesn't know exactly how to use those references in terms of model associations.

Specifically, we want the Expense model to have a many-to-one relationship with the Event model and a many-to-one relationship with the Vendor model. And because an expense knows about both its event and its vendor, the Expense model will implicitly represent a many-to-many relationship between events and vendors.

Declare the associations in the models as follows:

class Expense < ActiveRecord::Base
  belongs_to :event
  belongs_to :vendor
end

class Event < ActiveRecord::Base
  validates_presence_of :name
  validates_numericality_of :budget, :greater_than => 0.0

  has_many :expenses
  has_many :vendors, :through => :expenses
end

class Vendor < ActiveRecord::Base
  has_many :expenses
  has_many :events, :through => :expenses
end

Expense now has a many-to-one relationship with both Event and Vendor. We've also created an indirect relationship between Event and Vendor going "through" the Expense join model. The declarations read quite nicely: An expense belongs_to an event and an event has_many expenses. We can declare the model associations in a concise way and through the power of Ruby those declarations dynamically add methods to the enclosing class for managing the association.

Accessing Models Through the Back Door

Adding just a couple lines of code to the models has given us a bunch of new functionality. Before we start using it in our web application, let's experiment a bit with linking our models together. Type

 script/console

That command loads our Rails application into an interactive environment, then prompts you (shown below as the >> prompt) to enter Ruby code. It shows the value of each expression (shown below after =>) after you press Return.

Start by creating two new vendors in the database:

>> vendor1 = Vendor.create(:name => 'Parties R Us')
=> #<Vendor id: 1, name: "Parties R Us", ...>

>> vendor2 = Vendor.create(:name => 'Fire Department')
=> #<Vendor id: 2, name: "Fire Department", ...>

Next find an event you created earlier in the web interface:

>> event = Event.find_by_name('Chili Cookoff')
=> #<Event id: 1, name: "Chili Cookoff", ...>

Then create two expenses that link the event to each vendor:

>> event.expenses.create(:vendor => vendor1, :amount => 75.00)
=> #<Expense id: 1, event_id: 1, vendor_id: 1, ...>

>> event.expenses.create(:vendor => vendor2, :amount => 25.00)
=> #<Expense id: 2, event_id: 1, vendor_id: 2, ...>

Now you can access all expenses that directly belong to the event and all vendors that indirectly belong to the event through the expenses:

>> event.expenses
=> [#<Expense id: 1, ...>, #<Expense id: 2, ...>]


>> event.vendors
=> [#<Vendor id: 1, ...>, #<Vendor id: 2, ...>]

You can also calculate the total expenses for the event:

>> event.expenses.sum(:amount)
=> #<BigDecimal:1a04960,'0.1E3',4(8)>

Try navigating through the same associations, this time starting with a Vendor object. Then use quit to exit the session.

Adding Business Logic

Now that we can record expenses for a specific event, we can calculate the total expenses to see if we're within budget for the event. Models not only wrap database tables, they also encapsulate business logic such as this. So add the following method to the Event model:

def total_expenses
  expenses.sum(:amount) || BigDecimal("0.0")
end

This instance method uses the expenses relationship so that only those expenses belonging to a specific event are accumulated. We used similar code previously in script/console. Bottling those details up into a well-named method of the Event model helps keep our code clean and reusable. For example, we can also use the total_expenses method to write a new budget_exceeded? method to tell us whether an event is within budget. Add the following method to the Event model:

def budget_exceeded?
  total_expenses > budget
end

Writing Tests

Whenever we add business logic, trivial as it may be, we're wise to test it. Rails makes doing the right things easy. One of those things is testing. When we generated the event scaffolding, Rails went ahead and created a unit test for the Event model and a functional test for the EventsController. All we need to do is write a new unit test to cover the business logic we added to the Event model.

Add the following test method to the test/unit/event_test.rb file:

def test_budget
  event = Event.new(:name => 'Test Event', :budget => 30.00)
  event.expenses.build(:amount => 10.00)
  event.expenses.build(:amount => 20.50)
  assert event.save
  
  assert_equal BigDecimal("30.50"), event.total_expenses
  assert event.budget_exceeded?
end

The test uses the build method to create two expenses (in memory) and add them to the event's expenses association. Then the test saves the event (and its expenses) to the test database and asserts that the save operation returned true. With the event tucked away in the database, the test then checks that the event's total expenses is the sum of the expenses and that the expenses exceed the budget.

Run all the unit tests by choosing the "test:units" action from the Action toolbar item. All the tests should pass with the following output:

....
Finished in 0.1223 seconds.

4 tests, 6 assertions, 0 failures, 0 errors

Remember that Rails has three default runtime environments. When you run tests, Rails switches to the test environment. Among other things, that means the database configured in the test section of the config/database.yml file will be used. In our case it's a SQLite3 database in the db/test.sqlite3 file. The upshot is tests can muck with the database without affecting our development (or production) data.

In addition to unit tests, functional tests let you easily generate simulated HTTP requests against a controller, then assert that the controller works as you'd expect. You can also write integration tests to assert expectations across multiple controllers. To run all the unit, functional, and integration tests in one fell swoop, simply run rake. (As it stands, the functional tests fail because we've added validations to the Event model.)

Note: The content above being modified and rewritten again from Apple Developer Center

Mac Tablet Computing

2008-03-11T15:46:00Z

Axiotron ModBook

Axiotron Modbook is a tablet Mac which is retrieved by modifying MacBook. The ModBook is not designed for the masses, but that’s precisely why Apple hasn’t made a tablet Mac. Axiotron is authorized Apple solution provider. Apple is approving, even though it's not actually supporting. Maybe sooner or later, Apple will take part in the good market share for this kind of niche product solution, who knows?. You can read the forum to find out more about this cool device.

Mahalo Daily

Mahalo Daily came up with video introduction to this Axiotron Tablet Mac, which is also called Modbook

What's Cool Inside?

iSight-enabled video iChat
DVD movie watching
GPS unit based on the SiRF III chipset
A sensitive display fortified by Wacom's Penenabled hardware with 512 levels pressure detection.
Mac OS X's Inkwell handwriting-recognition technology
And more...

MacWorld

You should not miss this one. I also want to get one. I found out another video from MacWorld..