What's the difference between Regular Tasks & File Tasks in Rake?

I've been using Ruby extensively now for many years. Know that my entire web site is built automatically. That fitted well with Java XSL processors.

Developed by Jim Weirich. Process removing all the ant in favor of Rake. Explore some of the interesting features of Rake.

Rake is my third build language. (and have forgotten much of it). Last six years or so.

Have, and a few more that are (to me) new twists. Any automated build processing. You need to know Ruby to get Rake to do it's best things.

This is a somewhat skewed story. Interesting rather than give a complete coverage. Assume you know Ruby, Rake, or indeed any other build language.

Explain relevant bits of Ruby as I go along. Computational models, you'll find this worth a diverting read. Well no it isn't.

Rather than the usual imperative style. Differently about how to program them. Quite a profound difference.

It's time for an example. Program to build a project. Database structure and the code to access the database.

Compile: compile the application code. DataLoad: load test data into the database. Test: run the tests.

Ensure everything works. Compile and DataLoad need CodeGen run first. Express these rules?

Task a ruby procedure. Notice there's a problem with this. The codeGen step twice.

Multiple times is no different to calling it once. Take time, and builds are rarely things that have time to spare. This works, but it's a little messy.

Example of how a dependency based system can help. Imperative model, each routine calls the steps in the routine. Pre-requisite task once.

Sees it's dependent upon the codeGen task. CodeGen task and sees no pre-requisites. CodeGen followed by compile.

This is the same as the imperative situation. The interesting case, of course, is the test. Dataload (in any order) and finally test.

The build script. Really well, which is why all three use it. Slow down the build.

Model, but that's what it is. They are all examples of a Domain Specific Language (DSL). Are different kinds of DSL.

Rake is an internal DSL using Ruby. Things to ensure the rake scripts are valid ruby. Been a regular frustration using make and ant.

Writing build scripts. Rake defines two kinds of task. Tasks in ant, and file tasks are similar to tasks in make.

Either of those mean nothing to you, don't worry I'm about to explain. Regular tasks are the simplest to explain. Of my build scripts for my testing environment.

The first line defines much of the task. Being an internal DSL. Here there's just the one,:clean.

Syntax is => :clean. Inside the square brackets separated by commas. Brackets if there's only one task.

Fascinating topic in there that I'll get to later). To understand it to see how tasks work. Call it) is you can read this pretty clearly as a build script.

Works as valid ruby. It takes two arguments. (the equivalent of a map or dictionary).

Task, which helps to simplify the DSL. Identified in ruby by the leading colon. Constants too - which we'll discover to be rather handy.

Here we list the names of the other tasks. It I must say. So where's the second argument?

In the appropriate order. Scope when the block is actually executed. Admittedly arranged in a very odd way.

To have to have a pretty readable DSL. Procedure arguments helps this DSL stay compact. Allow us to package code in alternative control structures.

File task which is closer to the notion of tasks in make. Html' and 'dev/rake. Is the input.

How to make them. You need to run it. Modification date is earlier than the input file.

File by file basis. The |t| is doing. In the closure and call methods on it.

Duplicating the names of the files. (which is the output file) with t.name. List of prerequisites with t.prerequisites.

Same kind of necessity checking itself. Of the input files. Rake both rely on the build writer to write code for the task.

To check if things are up to date. In the rake tasks. This is what it would look like.

Rm, etc. It also provides uptodate? Perfect for these kinds of checks. So here we see two ways of doing things.

File tasks or regular tasks with uptodate? Whether to do things - which should we choose? I must admit I don't have a good answer to this question.

Tactics seem to work pretty well. Do, I did it mainly to see how it would turn out. To find out it's boundaries.

Or techniques in the early days. It's a natural part of learning. Pushing file tasks and fine-grained tasks too far.

Otherwise in a year or two's time, but so far I'm happy. What you find in ant and make. That rake does (and allows) that are a bit different.

These is allowing to specify dependencies in multiple places. Part of the dependent task. So far as well, like this.

Initially declared it. About a task in multiple places. Dependencies close to the pre-requisite task, like this.

Add a new bit of flexibility. Independent of both. To define dependencies?

Build file I used two rules of thumb. Such as the various errata pages. Put the dependency by the pre-requisite task.

Define the task. And add each to the group task. Task with its pre-requisites.

Further tricks to the build. Introduce some important principles about build processes. Clean builds are important, but they do take time.

It's useful to do incremental builds. In your output directories. Sources with the minimal amount of work.

Can occur here. Meaning that some items that should have got built didn't. An output element that didn't need to be built.

Because it adds time to the incremental build. To ensure that incremental builds work well. I want that to build only what I want to.

Work for my bliki. Xml files in my bliki directory. Page is the most important.

Source file to re-trigger the bliki build. I could do this by naming all the files like this. Fortunately I can do it this way.

In the bliki source directory. The file task. I'm not sure I really need this any more.

Default rake and there's no unnecessary rebuild. In for the moment. Defined for them.