Step 1:
In your config/routes.rb file add:

match 'sitemap', :to => "sitemap#index", :as => :sitemap

Step 2:
Create a controller called “app/views/sitemap_controller.rb”
Paste the following into it:

class SitemapController < ApplicationController
  def index
    static_urls = [ {:url => '/home/about',      :updated_at => ""},
                    {:url => '/home/help',       :updated_at => ""},
                    {:url => '/home/contact_us', :updated_at => ""},
                    {:url => '/home/terms',      :updated_at => ""} ] 
    @pages_to_visit  = static_urls
    @pages_to_visit += Article.all.collect{  |a| {:url => article_path(a) ,  :updated_at => I18n.l(a.updated_at, :format => :w3c)} }
    @pages_to_visit += Category.all.collect{ |c| {:url => category_path(c) , :updated_at => I18n.l(c.updated_at, :format => :w3c)} }
    respond_to do |format|
      format.xml
    end
  end
end

Step 3:
Create a view for the xml. I have used Haml for my view, you could use builder as an alternative. Call this “app/views/sitemap/index.xml.haml”

- base_url = "http://#{request.host_with_port}"
!!! XML
%urlset{:xmlns => "http://www.sitemaps.org/schemas/sitemap/0.9"}
  - @pages_to_visit.each do |page|
    %url
      %loc #{base_url}#{page[:url]}
      - if page[:updated_at].present?
        %lastmod= page[:updated_at]
      %changefreq= page[:changefreq].present? ? page[:changefreq] : "monthly"
      %priority= page[:priority].present? ? page[:priority] : "0.5"

Step 4:
Sitemaps require the date to be in the w3c DateTime format. This involves creating a specific Time format. In “config/locales/en.yml” add the following format:

en:
  time:
    formats:
      w3c: "%Y-%m-%dT%H:%M:%S+00:00"

Note: The timezone is has been hard-coded here. In ruby 1.9.3 you can specify “%:z” to get the timezone at the end of this, however heroku is running 1.9.1 so this cannot be done. However Heroku is at UTC time anyway so this does not matter!

If you don’t have anything custom inside this file that should be the entire contents of the file.
This means you can now use “I18n.l” to specify your custom timestamp format, for example:

I18n.l(a.updated_at, :format => :w3c)

which we used above.

And thats your sitemap on the fly! You could also generate a html sitemap if you wanted alongside this, or any other format you wish.
For the html one just add a format.html in the respond_to block of the controller and then add a new file in “app/views/sitemap/index.html.haml” and put your haml view for the html sitemap there. If you are not using haml substitute “.haml” for “.erb”

The courses are tailored to the ability of the group and we have run several different versions now, from basic programming skills all the way through to expert in different technologies or basic experience with rails.

All courses went really well and the feedback has been very positive:

“Excellent value for money, and I’m now coding RoR on a project!” – Dan Murphy

If you are interested in Dynamic50 running a course for your company, or would like to be included on the mailing list for our future courses please get in touch!, we’d love to hear from you.

Class User
  include Mongoid::Document
  embeds_many :children, :class_name => "Child"
  accepts_nested_attributes_for  :children, reject_if: proc { |attributes| attributes["age"].blank? }
end

Class Children
  include Mongoid::Document
  field :age, type: String
  embedded_in :user
  validates_presence_of :age
end

And on the view side then we can simply use simple_fields_for now as it is a now a nested attribute:

= f.simple_fields_for :children do |child_form|
  = child_form.input :age

You can now have as many children as you want and the form will pass the correct params back.

We are proud to announce the full launch of Chromaroma. Here at Dynamic50 we have been working with Mudlark on the development of Chromaroma for quite some time now. Dynamic50 took over the development work in September 2010 and several members of our team here have had the opportunity to work on it.

Development was led by one of our senior developers, Anup Narkhede, who has been working on the project since when we took it on in September. But along with Anup, special thanks must also go to Andy, Scott, and Jakub who also had a hand in making Chromaroma what it is today!

Since September, Chromaroma has seen huge improvements including two complete UI changes, new missions, new transport types, subscriptions and payment plans, as well as a lot of optimisation of the game mechanics engine. But to be honest, this barely covers what has been achieved!

In case you are not aware of Chromaroma, here is an excerpt from the press release:

“Chromaroma is an online multiplayer game using Oyster Cards and Bike Hire Keys. It allows users to embark on missions, collect items, gain points and meanwhile support your team members or make it all the more difficult for your opposition.

But Chromaroma is not just a game, it is a storytelling platform from where people can play as fictional characters or as themselves in the physical world.”

The press launch was this morning, which marks the official transition from beta to live. Congratulations to all involved, and thanks to Mudlark for choosing Dynamic50 to be part of such an exciting project!

To get started, simply register for an API key here: http://policeapi2.rkh.co.uk/api/docs/signup/ and then add the gem to your Gemfile:

gem "oldbill"

or you can just install it from the command line:

gem install oldbill

and then follow the instructions on the readme at https://github.com/hookercookerman/oldbill

The Police API allows you to download data about crime localised to your area within a date range, and is data direct from the UK police service. Enjoy!

Following on from our last post and the feedback we received, we have decided to move the Rails training course to run over a weekend rather than during the week.

• 9-10th April
• 23rd-24th April
• 16-17th April

We will be running small classes so we can pack as this makes for faster learning and a more one-on-one feel to it!

The course content will be the same for both weekends:
A basic understanding or programming will help but is not mandatory.

• Environment Setup
• Version Control overview
• Ruby kick start
• Introduction to the language
• Rails MVC overview and anatomy of a rails application
• Creating a rails project
• Using the generators
• Introduction to specs and tests
• Introduction to REST and Restful controllers
• Introduction to plugins, engines, and gems
• Learning to use Active model and active record
• Creating Views, Layouts, and reusable snippets (partials)
• Deployment with Capistrano and Git

Spaces are booking up fast, so to reserve your space go to http://rubyonrailstraining.eventbrite.com/, send us an email or call us on 0208 686 6372

We are holding a beginners to intermediate ruby on rails training course here at Dynamic50 on the 29th of March. The course will last 3 days and will cost £500 ex VAT. We have 4 places left so if you are interested in attending please get in contact by sending us an email.

A basic understanding or programming will help but is not mandatory.

• Environment Setup
• Version Control overview
• Ruby kick start
  • Introduction to the language
• Rails MVC overview and anatomy of a rails application
  • Creating a rails project
  • Using the generators
• Introduction to specs and tests
• Introduction to REST and Restful controllers
• Introduction to plugins, engines, and gems
• Learning to use Active model and active record
• Creating Views, Layouts, and reusable snippets (partials)
• Deployment with Capistrano and Git

Heroku doesn’t give you the ability to touch the VHost settings, which is where this sort of thing is usually done, but this is not a problem as you can simply use a bit of rack middleware to do the same thing. If you are looking for more complex rules than simply a rack rewrite of www to root, the I would suggest using something like John Trupianos’ Rack Rewrite.

Anyway the idea behind a rack rewrite on this is that so for example:

www.dynamic50.com

gets 301 redirected to

dynamic50.com

What this means is that you don’t end up with duplicate content on both www and the root domain, which is no good for SEO or for looking at your analytics.

So what do I write? Well first place this bit of code in “lib/middleware/www_middleware.rb”

class WwwMiddleware
  def initialize(app)
    @app = app
  end

  def call(env)
    request = Rack::Request.new(env)
    if request.host.starts_with?("www.")
      [301, {"Location" => request.url.sub("//www.", "//")}, self]
    else
      @app.call(env)
    end
  end

  def each(&block)
  end
end

And place the following in your “config/application.rb”

config.autoload_paths += %W( #{ config.root }/lib/middleware )

And this in your “config/environments/production.rb”

config.middleware.use "WwwMiddleware"

Real World

click here if you wish to see a real work example;

Ok what does this example have todo with creating validation on the fly???

In CarbonCalculated we get a CO2 result via sending a request to calculator giving some parameters via a HTTP GET Request; If you looked at the example that is essentially 1 calculator with many computations. So what?? Well in our carbon applications I don’t have to do any logic to try to determine what computation the user wishes to answer; Plan Train Bus Whatever; because the Calculator will ask the Computations which one is valid; Anyway enough
ranting lest see some code!!!

This is not the implementation in CarbonCalculated however same principle; CarbonCalculated API uses a little more magic for custom validators and uses mongomapper etc;

Storing And Using Validations

  require 'adapter/memory'
  require 'toystore'
  require 'ostruct'

  class Validation
    include Toy::Store
    store :memory, {}

    # == Attributes
    attribute :name, String
    attribute :message, String
    attribute :has_validator, Boolean, :default => false # For custom Validators
    attribute :key_name, String, :default => false
  end

  # == Computation Model
  class Computation
    include Toy::Store
    store :memory, {}

    # == Attributes
    attribute :name, String
    embedded_list :validations
  end

  # This is the class that we want a result from it uses the
  class Answer

    attr_accessor :computation, :attributes

    def initialize(computation, attributes = {})
      @attributes = attributes
      @computation = computation
    end

    def validations
      @computation.validations
    end

    # @return [Class]
    def build_validator
      useable_validations = validations
      Class.new(::OpenStruct) do
        include ActiveModel::Validations
        extend ActiveModel::Naming

        def self.name
          "Answer"
        end

        # may wish to override to support custom validations
        def self.validation_validator(val)
          val["key_name"].to_sym
        end

        def self.evaled_validation_options(validation_options)
          new_options = {}
          validation_options.each_pair do |key, value|
            new_options.merge!({key.to_sym => value.is_a?(String) ? eval(value) : value})
          end
          new_options
        end

        useable_validations.each do |validation|
          self.send(validation.name, validation_validator(validation))
        end
      end
    end

    def validator
      @validator ||= build_validator.new(@attributes)
    end

    def valid?
      validator.valid?
    end

    def errors
      validator.errors
    end
  end

  @computation = Computation.create!(
    :name => "simple computation",
    :validations => [Validation.new(:name => "validates_presence_of", :key_name => "name")]
  )

  a = Answer.new(@computation, {})
  a.valid?
  # false
  a.errors.full_messages
  # Name can't be blank

  a = Answer.new(@computation, {:name => "beans"})
  a.valid?
  # true

*.myapp.com
demo.myapp.com
hello.myapp.com
secure.myapp.com

This is a fairly straightforward process, however there appears to be no good documentation online on how to do it for wildcard domains.

As much as I dislike GoDaddy with their automatic renewal on everything and massive upsell, they are the cheapest and easiest to get started with on an SSL wildcard package. Just make sure you don’t end up buying something irrelevant during the payment process!
I bought the “Standard (turbo) wildcard SSL 1 year” which costs around £124 excl VAT. I tried 123reg previously but it seems that 123reg certificates do not work completely cross browser.

So to get started lets generate a CSR. I am assuming Mac OSX for this, although this should also work on Linux, but probably not on Windoze.
Do the following:

mkdir sslcerts;
cd sslcerts;

Now generate a key. Choose a passphrase you will remember when it asks you for one

openssl genrsa -des3 -out mykey.key 2048;

And generate the CSR (using the passphrase you just entered). As you are doing a wildcard domain make sure the organisational unit name and the common name are the same and are pre-pended with a * (see below for example).

openssl req -new -key mykey.key -out mycsr.csr;

Country Name (2 letter code) [AU]:GB
State or Province Name (full name) [Some-State]:London
Locality Name (eg, city) []:Croydon
Organization Name (eg, company) [Internet Widgits Pty Ltd]:My Company Ltd
Organizational Unit Name (eg, section) []:*.exampleapp.com
Common Name (eg, YOUR name) []:*.exampleapp.com
Email Address []:support@exampleapp.com

Please enter the following 'extra' attributes
to be sent with your certificate request
A challenge password []:
An optional company name []:

Leave the challenge and company name blank.

Double check you got this all correct as when you paste your CSR in, if you get the domain wrong you will have to request a refund and then reapply, not the quickest of processes! If you do this wrong, the best way to get a refund on it is to call them up.
You now paste your CSR up to the GoDaddy panel and then go through a series of confirmations on your domain. When you have finished these, the certificate will be issued.

Download your certificate and intermediate key (they come in a bundled dir). When you download choose “Other” as the format. You need to combine the two certificates so first move the two to your directory and then combine them:

cat myapp.com.crt gd_bundle.crt > myapp_bundle.crt;

Also bundle your cert and key together:

cat myapp_bundle.crt mykey.key > mypem.pem;

Finally we now need to remove the passphrase from the certificates:

openssl rsa -in mypem.pem -out final.pem;
openssl x509 -in mypem.pem >>final.pem;
openssl rsa -in mykey.key -out final.key;

And that is your certificates done and ready to upload to heroku.
Now on heroku log in and check that you have the Custom Domains and Custom Domains and wildcards add-ons and that your domain names are set correctly (ie that you have *.myapp.com and myapp.com set as domain names).

Now upload your ssl certs to heroku:

heroku ssl:add final.pem final.key

From you heroku control panel add Hostname SSL. Heroku will then send you an email with a DNS address for your app such as:

appid42352herokucom-324234.us-east-1.elb.amazonaws.com

Make sure you domain is pointing to this, so remove the existing CNAME record you have for your wildcard subdomains:

*.myapp.com.  -> proxy.heroku.com.

And create a CNAME record to make it point to the new amazon appid:

*.myapp.com. -> appid419658herokucom-96892355.us-east-1.elb.amazonaws.com.

Now this should all be working and after waiting for your CNAME to propagate, you should now be able to visit mysubdomain.myapp.com using ssl (https) and it should be valid and secure :-)

As a final quick hint, if you want to make sure that http requests get redirected to https automatically put the following in “lib/middleware/force_ssl.rb”:

class ForceSSL
  def initialize(app)
    @app = app
  end

  def call(env)
    req = Rack::Request.new(env)
    if env['HTTPS'] == 'on' || env['HTTP_X_FORWARDED_PROTO'] == 'https'
      @app.call(env)
    else
      [301, { "Location" => req.url.gsub(/^http:/, "https:") }, []]
    end
  end
end

The following into “config/application.rb”:

config.autoload_paths += %W( #{ config.root }/lib/middleware )

And the following into “config/environments/production.rb”:

config.middleware.use "ForceSSL"

Now your app will automatically route any http request to https, meaning ssl the whole time :-)
I grabbed this little bit of code for the SSL from somewhere but can’t remember where so please comment if you are the poster and I will credit you, thanks!

edit the ssl was taken from: Simone Carletti @ stackoverflow: http://stackoverflow.com/questions/3861772/force-ssl-using-ssl-requirement-in-rails-app