One of the best resources I’ve found so far are the defaults files in the Rails source code.

https://github.com/rails/rails/blob/master/activemodel/lib/active_model/locale/en.yml
https://github.com/rails/rails/blob/master/activerecord/lib/active_record/locale/en.yml

That gives you a full list of the attribute names to use for different validators.  For example, if you’re using a validates_format_of validator, you can quickly see that you need to use the invalid YAML attribute.  Good luck guessing that one!

The looking at the source trick can also be very useful for gems.  I’ve spent ages Googling for the correct YAML attribute to use for the validates_email_format_of gem with absolutely no luck whatsoever.  30 seconds on Github and I find the source file which tells me the attribute for an invalid email address is invalid_email_address

After some digging around I found various docs that suggested that you need to add the haml gem and include something like the following in application.rb

config.generators do |g|
  g.template_engine :haml
end

However, after a couple of attempts to generate HAML templates for a scaffold controller there was clearly something not quite right. I kept getting the following error:

error  haml [not found]

It turns out that the haml gem doesn’t give you generators for Rails 3.

After a bit more digging I found the haml-rails gem. Add that to your Gemfile and it adds generators for HAML, and enables it, so you can get rid of that declaration in application.rb

So now I’m all HAML’d up and ready to go. I like it so far, but we’ll see how I feel in a week or two of working with it.

Before

The Magical Pretty Print Button

After

The top conversion paths report is an awesome bit of kit; one of the five new multi-channel funnel reports in Google Analytics. The report shows a graphical table of the most common channels a user passes through to complete a site goal. The basic channel grouping is as follows:

Note that the channel listing follows an ordering process, in that visits which are not tagged as belonging to the first channel (Paid Advertising) fall through to the rule for the second channel, and so on. In the basic channel grouping, the direct channel also includes visits from a source/medium of “not set,” so that 100% of the site traffic is defined by this set of rules.

A classic example of how a visitor would interact with your site via different channels would be someone coming across your site via a Google search, bookmarking it, and then returning later via the bookmark to complete your goal:

This is great, and with a table full of information like this, there is plenty of information to extract. However, the real power of the report comes in defining your own channel groupings. For example, in the above we see that the user originally came across the site by an organic search. We could create two channels to replace this one, breaking it down further into searches that already knew of your brand, and searches that came across your site with no prior knowledge of it (filtering by keyword.)

In order to set up your own channels, a simple way to do so is to edit the basic grouping. An easy way to copy the basic grouping template is found in the channel groupings drop down above the data set:

To move the channel ordering, drag on the grey boxes on the left of the buttons. Highlight the right hand side of a button to edit:

The interface is the same as in the search filter and advanced segments, so to create another rule highlight the “add ‘AND’ statement,” and select the dimension of keyword as below. Enter your brand name, and relabel the channel title before saving. Your groupings will also then be able to be used in the assisted conversions report.

From here, you can edit and create more channels to suit your needs. Track campaigns, visits through your blog, visits from your twitter account, visits from retweets, visits from apps and much more; giving you the vital information on how all these channels interact.

Although this report is hidden away deep in the goals section of the standard reports in Google Analytics, the information gleaned from it is priceless for any site owner.

However my favourite of these recent announcements has been the inclusion of five powerful new reports under the label of multi-channel funnels. These new reports are sure to be highly useful tools for advertisers and business owners alike by allowing a more detailed analysis of how they are attracting the most important traffic to their sites.

The reports are found under the Conversions section of the Standard reports, and so in order to be useful, a site must have some Goals enabled. Note that goals do not have to be e-commerce related, but are an essential part of tracking and reaching the targets of any site. For example, if you run a small business and want to know who the people are that click on your contact page, you can set that up as a goal, and then analyse who accomplishes it – who converts.

An interaction with a site is defined by the visit received from a specific channel.  A channel can combine many different dimensions such as source, medium, keyword, campaign etc. The standard channels that the reports use are the following (for more info see here:)

Previously when trying to establish a picture of how effective specific marketing efforts were, Google Analytics would provide information of only the last interaction that led to a conversion. These new reports are extremely valuable as they can show us channels of visits to a site that a user makes within the 30 days before a conversion (provided cookies have not been cleared.)This is important, as a large number of visitors will browse around before eventually deciding to make a conversion.
Under the “Multi-Channel Funnels” heading, we are provided with five reports:

Overview Report – Provides a standard graph of goal conversions over time, allowing you to choose and compare between the conversions and assisted conversions metrics. Also includes a visualizer that produces a Venn diagram of conversions and assists between up to 4 selected channels:

Assisted Conversions Report – Allows you to compare the assisted conversions and final interaction conversions metrics. Also includes a ratio of the two, helping the user to analyse which channels spread knowledge of the site, and which lead to directly to conversions.

Top Conversion Paths Report – Shows in picture form, the paths that users took to convert. Also gives statistics on the numbers of people who took the specific path. For more info see here.

Time Lag – Give us information on how long users took to complete their path to conversion. Produces this in the form as below:

Path Length – Report produces a similar looking set of data to the Time Lag report, but instead of “Time Lag in Days,” shows us “Path length.”

Put together these reports give us valuable new insight into how a sites most important visitors access its most valuable content. For more information on the power of the top conversion paths report and on custom channel groupings, see our blog post here.

1. Open your gemfile and replace gem ‘rails’, ’3.0.0′ with  gem ‘rails’, ’3.1.3′.  3.1.3 being the latest build at the time of writing.
2. If you want to use the new asset pipeline hotness in 3.1 (and why wouldn’t you?) you need to add a new section at the bottom of the file:

   group :assets do
     gem 'sass-rails', "  ~> 3.1.0"
     gem 'coffee-rails', "~> 3.1.0"
     gem 'uglifier'
   end

3. Now open up your command line and run a bundle install. You may need to delete gemfile.lock.
4. The next step is to run rake rails:update.  The first time I did this I got the error “uninitialized constant ActionView::Helpers::JavaScriptProxy”.  To resolve this I removed jrails from my gemfile as Rails 3.1 uses jQuery anyway.  I then re-ran the rake command.
5. The Rails update will generate a bunch of conflicts.  I did the following (make sure you use the diff option to check for yourself!):
   • boot.rb – overwrite.
   • routes.rb – do not overwrite.
   • application.rb – do not overwrite. We’ll patch this up manually next.
   • development.rb – do not overwrite. You might be able to get away with overwriting this, but I have settings I need in here.
   • production.rb – do no overwrite. Again, I have settings I need in here.
   • test.rb – overwrite. I didn’t have any special settings here, but use the diff to check yours!
   • secret_token.rb – overwrite.
   • session_store.rb – overwrite.
   • en.yml – do not overwrite.
6. Now we need to make a few changes that would have been made if we let Rails overwrite our files. Open up config/application.rb and add the following:

   # Enable the asset pipeline
   config.assets.enabled = true
   
   # Version of your assets, change this if you want to expire all your assets
   config.assets.version = '1.0'

7. Open up config/environments/development.rb, remove “config.action_view.debug_rjs = true”and add the following:

   # Do not compress assets
   config.assets.compress = false
   
   # Expands the lines which load the assets
   config.assets.debug = true

8. Open up config/environments/production.rb and add:

   # Compress JavaScripts and CSS
   config.assets.compress = true
   
   # Don't fallback to assets pipeline if a precompiled asset is missed
   config.assets.compile = false
   
   # Generate digests for assets URLs
   config.assets.digest = true

9. Create a new assets folder in app and then add images, javascripts and stylesheets and sub-directories.  Move your CSS, JS and image files into these directories.
10. You’ll have to do some work to cleanup your assets and how they are included in your layouts – but that’s very much an exercise for the reader :)

This week it was granting permissions on a database.

To grant permissions on a database to a user you use something like…

GRANT ALL ON db1.* TO 'user'@'hostname';

Hostname can also be ‘%’, which is a wildcard for any host.

My gotcha was that ‘%’ does not include ‘localhost’, so the locally hosted application couldn’t access the database that I could connect to remotely.

It’s not immediately obvious in the documentation that this is the case.  It says that ‘%’ “ applies to user_name for any host in the 192.168.1 class C subnet”, which of course in hind-sight does not include ‘localhost’.  While the local machine is in that class-C in most networks, the connection will come via the loopback address, not through an external network, so it’s origin host will not be in the ‘%’ set.

It can seem slightly counter intuitive but it makes sense when you understand a little more about what’s happening.

The enhancements to CSS that are found in SASS and LESS are simply brilliant and save a massive amount of time.  Variables, nested selectors and mixins are just a few of my personal favourites.  CoffeeScript puts a wonderfully expressive veneer on top of JavaScript, removing lots of the grunt work and making your code much cleaner.

Using these improvements to the everyday languages has become second-nature and I’d be reluctant to go back.  Think about how much of a difference jQuery made to JavaScript DOM manipulation and animaton – you just wouldn’t want to go back to how it used to be!

However, my time is split between the Ruby on Rails world and the ASP.NET MVC world.  .NET doesn’t have native support for these new languages yet.  What’s a dev to do?

Thankfully, the lovely people of Mindscape have released a free Visual Studio plugin to take our pain away! The plugin handles CoffeeScript, LESS and SASS files, compiling them to native code every time you save your file.

It also adds new project items types to the ‘Add Item’ dialog and provides syntax highlighting within .coffee, .less and .sass files.

Simple and brilliant.  You can still link to your CSS and JavaScript files as you always have in HTML, or, as I do, use a NuGet package like Combres to combine and minify your files to reduce page load time.

I had an odd bug today when deploying a Rails app.  I have an AJAX call, that returns a javascript block.  The template is actually a CoffeeScript file with the name check.js.coffee, the idea being that the CoffeeScript gets compiled to JavaScript before being sent out.

This works absolutely fine in development mode on my Mac.

Deploy it to the server and I get

ActionView::MissingTemplate (Missing template projects/check, application/check with {:handlers=>[:erb, :builder], :formats=>[:js, "application/ecmascript", "application/x-ecmascript", :html, :text, :js, :css, :ics, :csv, :xml, :rss, :atom, :yaml, :multipart_form, :url_encoded_form, :json, :obj], :locale=>[:en, :en]}. Searched in:
* "/home/.users/70/revedadmin/online_editor/app/views"
* "/usr/local/lib/ruby/gems/1.9.1/gems/devise-1.5.0/app/views"
* "/usr/local/lib/ruby/gems/1.9.1/gems/kaminari-0.12.4/app/views"
):

The application is looking for check.js.erb or something similar.  It doesn’t know what to do with the CoffeeScript file.

It turns out that Rails won’t compile CoffeeScript templates by default, but you can install the Coffeebean gem and it magically works. It also has view helpers which let you drop CoffeeScript into an erb template like this…

<%= coffee_script_tag do %>
  alert 'coffee script is awesome!'
<% end %>

which is neat.

But the real gotcha is that this works out of the box in development mode, so you assume that it will work in development.

When in development mode, the asset compilation pipeline is appears to be compiling the CoffeeScript template at runtime. But with compilation turned off in production mode this no longer happens.

I assume this is not an intended behaviour as it rather breaks the idea of Rails apps working the same largely irrespective of the platform.  I will do some more digging.

The error is triggered when you request an instance of a service you have not wired up properly in your DI config.  It’s a classic case of the error message not actually telling you what the real problem is.  For example, I just added the new dependency on IDirectDebitProvider to my BillingController:

public BillingController(IOrganisationRepository org, IDirectDebitProvider dd)
{
    // implementation
}

However, I had not added the following line to my Ninject configuration:

kernel.Bind<IDirectDebitProvider>().To<SmartDebit>();

For more, read our getting started guide for DI with ASP.NET MVC.