Rails plugin that provides rake tasks for identifying missing specs

I have a bad habbit of generating my views while specing the controller and then never generating a view spec.
I wrote a rake task to tell me which views have no specs, kind of like a rcov for views.

I then realised that it could be useful to find all files with missing specs so now we have unspec’d, a Rails plugin that provides rake tasks for identifying missing specs

How to select an array of values in Rails

I recently wanted to get a list of IDs from rails, but wanted them in an array.

First try is to use :select => ‘id’ in:

but that creates a model for each id

In order to get an array of values, you can use select_values:

This is great, but what if you have a more complex query and you still want to use the query building in Rails finder methods.
You can use construct_finder_sql. This is a private method so it needs to be called via send and you should be cautious about it’s availability in future versions of Rails.
The final query then is:

This will be quicker and use less memory because it doesn’t create a model object for each id.
I would only use this when pulling fairly large arrays of values, stick to the normal way of doing things for smaller collections.

If you want to get two or three values per ‘row’, you can use select_rows which will return an array of arrays.

Accessing the Rails logger inside of library files

A quick tip, if you’re developing a library which lives inside of RAILS_ROOT/lib, you can use the Rails logger via DEFAULT_RAILS_LOGGER

I added if RAILS_DEFAULT_LOGGER so that it doesn’t trip up if used outside of RAILS

Download a large amount of data in CSV from Rails

I’ve just had to re-write an export script because the application now needed to be able to download 14000 records in CSV format.
Originally I was reading all the records (with multiple joins) and then creating a csv string and then writing it to the response using send_data.

The original code

This is a simplified version of my code

My first thought was to stream the data using

The problem with this is that send_file_headers! requires that the :length option be set. I also was running into the problem of loading 14000 records into memory before iterating over them.

For the memory problem, I considered using the new Model.find_in_batches but I needed to join tables and use some complicated conditions.

The solution

I finally settled on chunked reading of the data from the database and a more explicit use of render :text => Proc…

I hope this useful for you, if you have any questions, please ask in the comments.

Map Fields - A Rails plugin to ease the importing of CSV files

I’ve just released a plugin, map-fieilds, that eases the importing of CSV files.

When importing CSV files for a project, I wanted to add flexibility for the users so that they could import their CSV files in a looser format and then map their format to the format I needed.
map-fieilds will intercept calls to a method and show an intermediate screen where the user can map their columns to the expected columns.

How to install

In your environment.rb file:

If you prefer, it can be installed as a plugin:

Using it in your controller

lists_controller.rb:

Explanation

Setup map-fields

Setup map-fields at the top of the controller.
map_fields accepts three parameters

1. The first is the method to intercept, in this case :create
2. The second is an array of expected CSV fields. The order of the fields in this array is the order they will be available in the row object when finally reading the CSV file.
3. Lastly, a hash of options.
   :file_field is the field that contains the import file. This is :file by default
   :params is an array of parameters you want preserved. If you have a form based around a model, you just need to put the model name here and all the sub-fields will be preserved.
   So, if you have a form with list[:name] etc, use :params => [:list]

Create your new view with a file field

You can now setup your new view as normal with an included file field

Handle the mapping in your create action

The create action now has to perform two functions, the mapping and then the final creating.
You can call the fields_mapped? method to see if the mapping has been performed and if not, render the mapping view.
There is a mapping partial which you can use so your view is as easy as:

and it produces the following:

When the fields have been mapped, you can iterate through them with:

Two errors can be raised:

1. MapFields::InconsistentStateError is raised when map-fields is unable to determine whether a file is being uploaded or mapped. It can be experienced through a combination of using the back button and refreshes but is seldom experienced.
2. MapFields::MissingFileContentsError is raised when no file has been uploaded

Please feel free to ask any questions in the comments and raise issues on the GitHub page.

Conditionally include development gems

I was playing with metric_fu and after having to install multiple dependency gems I realised that it was going to be a pain to put the project into production.

The metric_fu instructions suggest using config.gem in your environment file but that will mean that when you push the app to production, you need to install the metric_fu gem and all it’s dependencies. Considering metric_fu is only used for development, I needed a way around this.

I decided to wrap the Rakefile entry in an environment check

This allows metric_fu to run in either test or development and won’t even try to load the gem in production.

Easily compare a variable with multiple values

I often forget this simple little trick for comparing multiple values against a single variable.

Instead of

You can do the following

Setting the session base domain in Rails 2.3

Prior to Rails 2.3, you could set the session base domain as follows:

In Rails 2.3, this needs to change to:

I usually set this in my config/environments/.rb configuration files but it could be set in config/environment.rb if you want it to apply across configurations.

Background

This setting will allow for a shared session across multiple subdomains.

This is useful where you want a user to login at www.example.com and then be able to remain logged in when accessing user.example.com

Using Webrat’s save_and_open_page on Linux

Mmmm, this year has flown and I have done hardly any blogging, despite my intention to blog at least once a week. Oh, well. My excuse is working extra hard to cover a family holiday and the upcoming trip to Scottland on Rails.

The best way to get going on something is to just do it so here is a quick post on how to view the page you’re working on in Webrat with it’s save page feature when on Linux (It is currently only works on Windows and Mac)

A quick monkey patch in your test helper or Cucumber env file:

This is not perfect because it is specific to using Firefox, but I know most of you use Firefox anyway, and at least it will continue to work for those using Windows or Mac

Now let’s hope I can get my work load under control and post more frequently.

New Rails plugin - Quick Scopes

I’ve just release a new Rails plugin called Quick Scopes that adds some generic named_scopes to your models to quickly manipulate the results you receive from associations.

It’s great to have easy access to methods to get all associations but sometimes you need to manipulate how you receive those results.

Included named_scopes:

• limit - to limit the number of results
• order - to order the results
• where - alias for conditions
• with - alias for include

Examples

If you need all the manipulation of the last couple of examples, you probably should create a specific named_scope but this can be very useful to have available on the console.

Have a look and let me know how it works for you and what you would do differently.

Quick Scopes: http://github.com/internuity/quick_scopes

Install