Using Coffeescript on Windows

CoffeeScript is a new language / add-on / icing sugar over regular JavaScript. If anyone has not heard of it, you can read this excellent introductory article .

By its magical nature, the compiler itself for coffee-scripts is written on the coffee-script. But fortunately, the CoffeeScript source package already contains ready-to-use js scripts. And now I will tell you how to use them in windows with the help of Node.js, Cygwin and Nant, for this is not a simple matter, at first glance.

What do you want?

So, to begin with, let's define the structure of a simple project with which we will work:

 Project
 + --- CoffeeScripts
 |  \ --- roast.coffee
 + --- JavaScripts
 | --- Tools
 |  + --- CoffeeScript
 |  + --- CygwinLite
 |  + --- NAnt
 |  \ --- NodeJs
 \ --- compile.bat 

The goal is to run compile.bat in the project root, which will compile all the scripts from the CoffeScripts folder to the JavaScripts folder.
')
The following programs will help us with this:

• CoffeeScript itself;
• Node.js to run a coffee compiler;
• Cygwin-Lite for converting file paths to unix view;
• Nant is an assembly system for all of this porridge.

As an example, we will compile the following simple coffee-script " roast.coffee ":

 roast = (what) ->
	 "Roasted # {what}"	
 console.log roast 'coffee!' 

CoffeeScript

The latest version of the package can be downloaded from github or cloned using the following command:

  git clone http://github.com/jashkenas/coffee-script.git 

There are two js scripts in the CoffeeScript \ bin folder: cake and coffee. Cake is a build system for make and rake projects, written in CoffeeScript, but we will not use it in this article. Coffee - the compiler of coffee-scripts in js-scripts. This is what we need to have.

Node.js

The binary assembly node.js for Windows can now be easily found on the Internet. Personally, I am currently using version 0.2.2 from this site .

Already at this step, you can run coffee. Suppose that the PATH environment variable contains the path to the node.js folder, and as an exercise, execute the following command " coffee --version ":

 C: \ Project \ Tools \ CoffeeScript \ bin
 > node coffee --version
 CoffeeScript version 0.9.4 

However, everything is not so simple if you need to call coffee not from its bin directory. Since node.js is compiled for windows using Cygwin, all paths in parameters to such programs must be specified in unix form via cygdrive (for absolute paths):

 D: \
 > node / cygdrive / C / Project / Tools / CoffeeScript / bin / coffee --version
 CoffeeScript version 0.9.4

To make such calls easier, you can use the following wrapper for coffee in the form of the " coffee.bat " coffee.bat , which you need to save to its bin-directory:

 @pushd.
 @cd / d% ~ dp0
 @node coffee% *
 @popd

Now the call to coffee is simplified:

 D: \
 > C: \ Project \ Tools \ CoffeeScript \ bin \ coffee --version
 CoffeeScript version 0.9.4

Now you can compile our roast.coffee and get the result on the console:

 C: \ Project
 > Tools \ CoffeeScript \ bin \ coffee -c -p /cygdrive/C/Project/CoffeeScripts/roast.coffee
 (function () {
   var roast;
   roast = function (what) {
     return "Roasted" + (what);
   };
   console.log (roast ('coffee!'));
 }). call (this);

As you can see, it still remains necessary to specify the unix-path in the parameters to the compiler.

Here comes to help us ...

Cygwin-lite

... Or rather, its powerful utility cygpath.exe.

Cygwin-Lite is very heavily clipped Cygwin, which, because of its small size, can be stored along with the code (yes, I like to store everything for assembly along with the project). Download Cygwin-Lite here . Although only cygpath is enough for us to compile, I did not find where it can be downloaded separately from the package.

We will use cygpath with the following parameters:

 cygpath -a -u windows-filename

This allows you to convert windows-paths to absolute unix-paths. Example:

 C: \ Project \ Tools \ CygwinLite \ bin
 > cygpath.exe -a -u cygpath.exe
 /cygdrive/c/Project/Tools/CygwinLite/bin/cygpath.exe

Compile.bat

OK, let's finally write a batch file for compiling scripts!
For the purity of the experiment, we will not use environment variables and homemade coffee.bat.

 @echo off

 REM Folder with source scripts
 set sourceDir = CoffeeScripts

 REM Folder for compiled scripts
 set destDir = JavaScripts

 REM Folders Used Utilities
 set cygwinDir = Tools \ CygwinLite \ bin
 set coffeeDir = Tools \ CoffeeScript \ bin
 set nodeDir = Tools \ nodejs

 REM Get the unix paths for the destination folder and before the coffee compiler script
 for / f %% o in ('% cygwinDir% \ cygpath.exe -a -u "% destDir%"') do set outputPath = %% o
 for / f %% c in ('% cygwinDir% \ cygpath.exe -a -u "% coffeeDir% \ coffee"') do set coffeePath = %% c

 REM For each coffee-script ...
 for %% f in (% sourceDir% \ *. coffee) do (
   REM ... we get its unix-way, ...
   for / f %% s in ('% cygwinDir% \ cygpath.exe -a -u %% f') do (
     REM ... and compile it into javascript in the destination folder!
     % nodeDir% \ node% coffeePath% -c -o% outputPath% %% s
   )
 )

 echo done!

Run compile.bat and get the compiled roast.js in the JavaScripts folder:

 C: \ Project
 > compile.bat
 Done!


 C: \ Project
 > type JavaScripts \ roast.js
 (function () {
   var roast;
   roast = function (what) {
     return "Roasted" + (what);
   };
   console.log (roast ('coffee!'));
 }). call (this);

Hurray, it works! But to build large projects you need something cooler than a batch file.

Use Nant

For those who are not familiar with NAnt, a small educational program.

NAnt is a free tool for building and deploying .NET projects. At one time, NAnt was ported from Ant (build system for Java) to the .NET framework and tailored to the needs of .NET developers. But with good imagination, this thing can be applied to anything. Currently, NAnt can be run both under windows and under linux using Mono. Its advantages: can do a large number of tasks and functions right out of the box, there is error handling, plus good extensibility and third-party plug-ins.
Links on which you can continue acquaintance with Nant:

• NAnt Home Page
• Automating the assembly of web applications on the .NET platform
• A Brief Introduction to NAnt
• Dimecasts.net: NAnt Episodes (screencasts)

And so, I assume that you have some idea about Nant, and now we will write a build script that will compile coffee scripts, similar to the previous compile.bat.

 <? xml version = "1.0"?>
 <project xmlns = "http://nant.sf.net/release/0.90-alpha1/nant.xsd" name = "Coffee test">

   <! - Set the environment variables for the script.  The path to cygwin is required to use the function $ {cygpath} ->
   <setenv>
     <variable name = "PATH" value = "Tools \ CygwinLite \ bin; Tools \ nodejs;% PATH%" />
   </ setenv>
  
   <foreach item = "File" property = "filename">
     <in>
       <items basedir = "CoffeeScripts">
         <include name = "*. coffee" />
       </ items>
     </ in>
     <do>
       <exec program = "node">
         <arg line = "$ {cygpath :: get-unix-path ('Tools \ CoffeeScript \ bin \ coffee')}" />        
         <arg line = "- c" />
         <arg line = "- o $ {cygpath :: get-unix-path (path :: get-full-path ('JavaScripts'))}" />
         <arg line = "$ {cygpath :: get-unix-path (path :: get-full-path (filename))}" />
       </ exec>
     </ do>
   </ foreach>
 </ project>

Save the build script as " compile.build " and write a new " compile.bat " to run it:

 Tools \ Nant \ bin \ nant.exe -buildfile: compile.build

Roasting coffee

 C: \ Project \ JavaScripts
 > node roast.js
 Roasted coffee! 

Good luck!