(Which I might add, I'm still using the initial CTP without any trouble and the application is in production. So if your wondering if in preview 4 its ready for production use... stop wondering)

The problem I introduced was changes to sass files required a VS build in order for the rake task to execute and reproduce the css files. This increased the turn around time to around 15 seconds, unacceptable.

The solution I was aiming for was a file system watcher that looked at the sass directory and any changes to my sass files immediately.

I found this filesystemwatcher code that looked pretty easy to implement (im a ruby noob still), so I moved those files to my tools directory and required them in my rakefile.rb

    require 'rake'
    require File.join(File.dirname(__FILE__), 'tools/haml-2.0.2/lib', 'sass')
    require File.join(File.dirname(__FILE__), 'tools/fsw', 'servicestate')
    require File.join(File.dirname(__FILE__), 'tools/fsw', 'filesystemwatcher')

As you can see, I've placed the filesystemwatcher files into my tools directory, again allowing the application to only rely on ruby and not obscure plugins.

The next step is to call the sass generation on the various FSW Events (Created, Modified, and Deleted)

    desc "Watches sass directory and generates css on save."
    task :watch_sass do
        _sass2cssAll
        css_dir = File.join(File.dirname(__FILE__), 'src/app/mvc/content/css')
        sass_dir = File.join(css_dir, 'sass')
    
        watcher = FileSystemWatcher.new()
        watcher.addDirectory(sass_dir, "*.sass")
        watcher.sleepTime = 1
        watcher.start { |status,file|
            case status
                when FileSystemWatcher::CREATED
                    _sass2css(file, css_dir)
                when FileSystemWatcher::MODIFIED
                    _sass2css(file, css_dir)
                when FileSystemWatcher::DELETED
                    puts "deleted: #{file}"
            end
        }

        watcher.join() # join to the thread to keep the program alive
    end

I refactored my :sass2css task so it calls straight into _sass2cssAll. The reason for this is that invoking the task from within the watcher was causing subsequent changes to not be picked up. I didnt investigate this too much.

I also extracted a method _sass2css so that the watcher only reproduced the css file in question, and not all of them.

Here are the 2 methods I extracted...

    def _sass2cssAll
        stylesheets_root = File.join(File.dirname(__FILE__), 'src/app/mvc/content/css')
	
	Dir[stylesheets_root + "/sass/*.sass"].each do |source|
            _sass2css(source, stylesheets_root)
	end
    end

    def _sass2css(source,stylesheets_root)
        target = File.join(stylesheets_root, File.basename(source, ".sass") + ".css")
        puts "Sassing #{source} to #{target}"
	puts ""
	File.open(target, "w") { |f| f.write(Sass::Engine.new(IO.read(source)).render)}
    end

All that I need to do now is fire up the watcher when I start development an watch those css files change!!

So the first step was getting a 'Hello Rake World' task running on my Windows dev machine, just to get all the working parts in place. I installed ruby, and then created a RakeFile.rb in the trunk of my application. The following is my uber complex :hello_world task.

    
    
        desc "Hello World"
        task :hello_world do
	    puts "Hello Rake World!"
        end
    

Running this at the command line gave me the following output:

The next step was to be able to call Rake tasks from Nant. Im not sure if this is a particulary elegant way to go, but Nant is contolling my build so it made sense for now.

The following Nant target calls the :hello_world rake task:

All im doing here is calling the rake.bat batch file. I am passing it the rakefile that sits in my applications trunk, specifying the hello_world target and setting the working directory to be the ruby bin directory (specified in a Nant property).

Calling that nant target at the command line yielded the following output:

So far so good, I have a nant target that can run in my build process that can call a rake task, time to start doing something useful.

I then installed the haml gem and copied the haml-2.0.2 directory over to my tools folder in my application. I don't mind having a dependency on Rails being installed on a development machine, but dependencies on gems isn't suitable.

I require the sass in my rakefile with the following. Its not necessary to require haml since we only make use of the Sass rendering engine.

    
        require File.join(File.dirname(__FILE__), 'tools/haml-2.0.2/lib', 'sass')
    

Now with the help of this post I was able to put together a task that converted any .sass file in my css/sass directory to the associated .css file.

    
    
        desc "Regenerates all sass templates."
        task :sass2css do
	    stylesheets_root = File.join(File.dirname(__FILE__), 'src/app/mvc/content/css')
	
	    Dir[stylesheets_root + "/sass/*.sass"].each do |source|
		target = File.join(stylesheets_root, File.basename(source, ".sass") + ".css")
		puts "Sassing #{source} to #{target}"
		puts ""
		File.open(target, "w") { |f| f.write(Sass::Engine.new(IO.read(source)).render)}
	    end
        end
    

All that remained to do was call this task from within my nant file, and I have my css being generated as part of my build. I also called this from my VS build, so when I change my sass files and recompile, the rake task is called and the css files are regenerated.

Now I've actually gone 2 steps forward and 1 step back here. Previously css changes were visible in my site by simply saving the stylesheet and refreshing, but now I have to recompile, which means my feedback cycle for css changes has gone from roughly 1 second to about 15 seconds, and this is unsatisfactory.... But ill address that in part II.

Enjoy.

desc "Retrieve production comatose pages"
task :get_comatose_pages do
  run "cd #{current_path}; rake RAILS_ENV=production comatose:data:export"
  system "scp #{user}@#{domain}:#{current_path}/db/comatose-pages.yml db/"
  system "rake comatose:data:import"
end

So I turned it into this:

Now you can too with this

 
Inflector.inflections do |inflect|
  inflect.irregular "status", "status"
end