
When building a web app, one of the first features you usually add is the ability for users to register and log in to see their data linked with their personal account. And most of the time, you will be using validations on your User model to ensure that the email is formatted like a real email address, and password is at least characters, and so on. 

_(Side note: If you don't know about validations, check them out at the [official Rails guide](http://guides.rubyonrails.org/active_record_validations_callbacks.html) - they're dead useful.)_

In this post, I'll be referencing the authentication gem [Authlogic](https://github.com/binarylogic/authlogic) and the fact that it automatically handles user model validations for you. If you're using another gem/plugin or building your own authentication system, you're probably interested in the [ActiveRecord's validation documentation](http://guides.rubyonrails.org/active_record_validations_callbacks.html). 


## Gradual Engagement

Anyways, so now you have your validations in place. But what if you want to enable access for "guest" users, or allow users to omit information like emails or passwords under certain circumstances? 

Coined **"gradual engagement"** by the Rails/Authlogic community, there's a simple way to do this. I spent a couple of frustrated hours this morning stuck on this problem and hunting through Google Groups logs, Github Gists and various blogs, so I'm happy to share. From [Kevin Triplett's Github Gist](https://gist.github.com/459563), all you need to do is add certain config options to your acts_as_authentic line in your model. 

In my case (in `app/models/users.rb`):
    
```rb
acts_as_authentic do |c|
  c.merge_validates_format_of_login_field_options :unless => :guest?
  c.merge_validates_length_of_login_field_options :unless => :guest?
  c.merge_validates_length_of_password_field_options :unless => :guest?
  c.merge_validates_format_of_email_field_options :unless => :guest?
end
```

## Multiple validation groups
Alternatively, if you want to have finer grained control over what validations are enabled when and have multiple "validation groups" to turn on and off, I stumbled across another solution that might interest you: Put [this code](https://github.com/railsdog/spree/blob/52105befa0c0533caa21aa81a55c897bc1c34198/lib/validation_group.rb) in your `lib/` folder. In your model of interest, add these lines to configure your validation groups (courtesy of Alan Gutierrez from the Authlogic Google Group):

```rb
class User < ActiveRecord::Base
  validates_presence_of :first_name, last_name, :email
  validation_group :invitation, :fields => ["email"]
  validation_group :registration, :fields => ["first_name", "last_name"]
end
```

And:

```rb
@user.enable_valiation_group(:invitation)
@user.save! # Will only validate email.
```

Easy peasy.


Rails Authlogic Conditional Validations


When I revamped my portfolio, one of the major changes I did was to change my attachment process to upload files (screenshots of my projects, etc) to Amazon S3 instead of to the local
filesystem.

## Why S3?

Putting large media files on S3 (aka "content storage/distribution") is a great idea because:

1. You don't have to use up large amounts of storage on your web hosting plan, and S3 is super cheap. Even if you have an unlimited storage plan or aren't worried about using it up, this is still good idea because your files are all stored externally so you don't have to worry about backing them up or moving them if you want to switch hosts later (like I did).

2. Amazon S3 is cheap (can you say "less than five cents a month"?), fast, scalable, and reliable. And probably many more nice things that I'm forgetting.

3. Rails is slow, and going through the application stack to pull images all the time is slow.

Now that I've convinced you, I'm going to show you how incredibly easy it is to have your uploads upload directly to S3 with the help of a handy plugin called [Paperclip](https://github.com/thoughtbot/paperclip).

## Uploads with Paperclip

Note, this is assuming that you are already using Paperclip in your app for your file attachment service. To do that, there's a great Quick Start guide [here](https://github.com/thoughtbot/paperclip).

First, add the aws-s3 gem in your Gemfile (you are using Rails3's bundler, aren't you? If not, [get started](http://gembundler.com/rails3.html)):

```rb
gem 'aws-s3', :require => 'aws/s3'
```

Next, create a file called s3.yml in your config/ directory (where database.yml lives as well):

```rb
access_key_id: [YOUR AWS ACCESS KEY]
secret_access_key: [YOUR AWS SECRET KEY]
```

In whatever model you created for the uploaded object(s), for instance mine is
Photo, add the following parameters to the usual Paperclip command like so:

```rb
has_attached_file :photo,
                  :storage => :s3,
                  :s3_credentials => "#{RAILS_ROOT}/config/s3.yml",
                  :s3_permissions => "public-read",
                  :path => ":filename",
                  :bucket => [YOUR S3 BUCKET NAME]
```                  

And that's it! Now whenever you upload files via Paperclip, the files will be automatically uploaded to the proper S3 bucket and the resource URL will point to the S3 static url.

Have fun uploading!



Paperclip + S3 with Rails


With any launched web app, it's a _very_ good idea to set up some kind of exception notification - in fact, it's on my [top 3 "Launch Checklist"](/my-launch-checklist/).

Exception Notification is a handy service that plugs into your existing app and sends you an email if (when) any exceptions are thrown in the course of people using your application. With Rails 3 and the [exception_notification](https://github.com/rails/exception_notification) gem, it's almost laughably easy to set up.

First, add the following to your `Gemfile`:

```rb
gem "exception_notification",
    :git => "git://github.com/rails/exception_notification.git",
    :require => "exception_notifier"
```

Then, insert this little snippet in `config/application.rb`, in the config block:

```rb
# Exception Notification
config.middleware.use ExceptionNotifier, {
 :email_prefix => "[Website Error] ",
 :sender_address => '"Notifier" <notifier@yourdomain.com>',
 :exception_recipients => ['you@yourdomain.com']
}
```

That's it! Wasn't that easy?

## Testing

If you're clicking through your application trying to get an exception thrown (but of course your application is written so well you frustratingly can't fire off an error), it might also be a good idea to create a method that tests your exception notification.

Just add a method that raises an exception in your `app/controllers/application_controller.rb`:

```rb
def test_exception
    raise 'Testing, 1 2 3.'
end
```

(Don't forget to add a route to `config/routes.rb` if you need it):

```rb
match "test_exception" => "application#test_exception_notification"
```

Now, you can visit http://yourwebapp.com/test_exception_notification to trigger the exception notification manually and test if the emailing works.

What if something goes wrong? All of the exception notification mailer's activity is logged, so go check out the relevant (development or production) log in log/

```bash
tail -f log/production.log
```

You also might want to turn off `ActionMailer` from sending email notifications when you're testing things out (application-wise, not exception notification-wise) on your development server. Just stick this code in `config/environments/development.rb`:

```rb
config.action_mailer.perform_deliveries = false
```

Cool, now you've got your very own exception notification set up! Happy debugging! (:



Rails exception_notification Setup


Sometimes when I'm coding Rails applications, it's useful to split up CSS and Javascript files by controller/views to prevent loading a huge CSS or Javascript file (containing all of the styles and code for the entire application) on every single page of the application when you only really need it for a specific set of your pages.

To load these dynamically (without having to include each named stylesheet by hand on each page), use the following code in the head of the main application layout:

```rb
<% filename = controller.controller_name %>
<% if FileTest.exist?  RAILS_ROOT + "/public/stylesheets/" + filename %>
  <%= stylesheet_link_tag "#{filename}" %>
  <%= javascript_include_tag "#{filename}" %>
<% end %></code>
```

This assumes that your stylesheets and javascript files are named according to the controller views in which they appear; if you'd just like to include javascript files of your choosing on certain views, put this in the head of the main application layout:

```rb
<%= yield(:header) %>
```

And insert this code in your view with the appropriate CSS and javascript files you'd like to include:

```rb
<% content_for :header do %>
  <%= javascript_include_tag "file.js" %>
  <%= stylesheet_link_tag "file.css" %>
<% end %>
```

Dynamic Stylesheet/Javascript Loading in Rails


A couple of days ago, I saw one of the coolest CSS tricks I've seen in a really long time. You know how people usually put their email as "amber DOT feng AT gmail DOT com" or something to that effect in an attempt to foil bots from spamming their email? Instead, you can type your email in backwards in the code (which is what will show up in the DOM and what bots will see) like so:

```html
<span class='reverse'>moc.liamg@gnef.rebma</span>
```

..and apply CSS styling to reverse the text:

```css
.reverse{
    direction: rtl;
    unicode-bidi: bidi-override;
}
```

Here's the snippet in action (try copy and pasting it somewhere!):

<span style='direction: rtl; unicode-bidi: bidi-override;'>moc.liamg@gnef.rebma</span>



Reversing Text with CSS


When I first started writing [Expendite](http://expenses.amberfeng.com), an expense sharing web application targeted toward apartment-mates, I barely knew Rails. For each expense, I needed a way to record which users were involved as parties. Basically I needed a many-to-many association with a join table, though I didn't know it at the time.

Embarrassingly, I chose the method of storing an array of user id's (the involved parties) in a `parties` column in my database. Now I know better, but it still may be useful to know how to store arrays in a database that seemingly doesn't have any support for array objects.

Luckily, ActiveRecord has this support built right in!

First, the column in question should be changed to type `text`. If you've already created and used your database, a simple database migration is in order. Next, serialize the column:

```rb
class Expense < ActiveRecord::Base
    serialize :parties
    # other model code
end
```

That's literally all you need to do! Now, just save an array to the column like you would normally save a field value:

```rb
Expense.new(:parties => [1, 2, 3])
```

And when you call the parties on an Expense again, it'll spit an array back at you. It's also worth noting that this technique may be used for hashes as well!

**Note**: Storing arrays in databases is *most likely* not what you want to do.

There's probably a relationship/associations solutions (like my anecdote), or you can figure out another way to make it work with multiple columns.


Storing Arrays in a Database Field w/ Rails ActiveRecord


This is basically the same deal as the Restful Authentication post below. I've used RSpec in the past (these quick start-up guides are not for beginners), I just need somewhere to quickly reference the beginning commands/code snippets to start my Rails applications.

Here it goes!

## Installing RSpec and RSpec for Rails

    sudo gem install rspec
    sudo gem install rspec-rails

## Generate RSpec subdirectory for tests

    script/generate rspec

Use RSpec scaffolding tool instead of regular scaffold! This way, you get the basic tests for each new controller/model/view you are creating.

    script/generate rspec_scaffold model_name ...

If you're looking to learn RSpec, [The RSpec Book](http://www.pragprog.com/titles/achbd/the-rspec-book) is an excellent reference.


Rails: Starting RSpec


I almost always use Restful Authentication for my Rails applications. (For those of you who don't know what Restful Authentication is, it's a widely used Rails plugin for managing user authentication. In short, it's a plugin/gem that easily allows you to
have users logins/etc on your application without the hassle of coding and debugging the entire thing yourself. The source code can be found on technoweenie's GitHub [here](http://github.com/technoweenie/restful-authentication).)

What's annoying to me is that I always forget how to set it up, and I hate going through loooong Restful Auth tutorial sites to find the specific commands/code snippets that I need. So here's what you need to set it up, short and sweet!

## Installing the plugin

If this doesn't work, just download straight from the GitHub (link above) and include it in your `vendor/plugins` folder

    ruby script/plugin install http://github.com/technoweenie/restful-authentication.git restful_authentication


## Generation

Generate all necessary files. Skip the `--include-activation` part if you doesn't want users to have to "activate" their accounts via email.

    ruby script/generate authenticated user sessions --include-activation

My generator fills in all the necessary routes automatically, but here they are just in case.

```rb
map.activate '/activate/:activation_code', :controller => 'users', :action => 'activate'
map.signup '/signup', :controller => 'users', :action => 'new'
map.login '/login', :controller => 'sessions', :action => 'new'
map.logout '/logout', :controller => 'sessions', :action => 'destroy'
```

## How to use

Include this line in your `ApplicationController`:

```rb
include AuthenticatedSystem
```

Include this filter in any controller where you want users to log in before they see content. You can selectively filter certain methods with the `only` keyword.

```rb
before_filter :login_required
```

Up to this point, the application should work for simple user authentication without activation by email (let me know if I'm missing anything!). I'll be writing more on activation as soon as I remember how I did it before.


←

web