rake sh en otro directorio

Problema: Quiero ejecutar un comando desde otro directorio en rake (por ejemplo, ejecutar un makefile que está en un subdirectorio).
Solución: Agrego al rakefile la posibilidad de ejecutar comandos en otro directorio. Para eso, al principio de mi rakefile puse:

require 'fileutils'

def sh_in_dir( dirname, *args, &block )
  old_path = pwd
  FileUtils.chdir( dirname )
  sh( *args, &block )
  FileUtils.chdir( old_path )
end

Happy hacking,
Aureliano.

Rakefile multiplataforma para erlang

Los últimos días estuve programando un toque en Erlang. Como estoy tratando de armar un proyectito algo más en serio, necesito algo como un makefile. Y como los makefiles son un dolor de huevos, decidí que es mejor hacer un rakefile.
Para eso estuve googleando un poco y encontré este post. Que casi resolvía los quilombos, pero le falta poder andar en Windows. Así que lo toquetié un poco para hacerlo multiplataforma.
Las cosas que tuve que hacer son:

• Usar ruby en vez de llamar a pwd para obtener el path actual.
• Generar nombres de archivos con back-slashes.
• Hacer que maneje bien cosas con espacios.

Para obtener el PATH actual hice esto:

PWD = Pathname(".").realpath

Para que el Pathname fuera con backslashes, después de consultarlo con Luis Lavena, monkey-patchié Pathname para que el to_s mande "back-slashes":

#Hack to generate paths with back-slashes
class Pathname
 alias_method :old_to_s, :to_s
 def to_s
   File::ALT_SEPARATOR ? old_to_s.gsub(File::SEPARATOR,File::ALT_SEPARATOR) : old_to_s
 end
end

Por último, cambié un toque las llamadas a "sh" para que maneje paths con espacios. Para eso, en vez de pasarle un String le paso un Array por parámetro. Las llamadas quedaron algo así:

sh *%W{erl -switch param1 #{param_calculado}}

Al final, el Rakefile quedó así:

#Based on the Rakefile shown in http://medevyoujane.com/blog/2008/8/21/erlang-make-rake-and-emake.html

require 'rake'
require 'rake/clean'
require 'pathname'

#Hack to generate paths with back-slashes
class Pathname

alias_method :old_to_s, :to_s

def to_s
 File::ALT_SEPARATOR ? old_to_s.gsub(File::SEPARATOR,File::ALT_SEPARATOR) : old_to_s
end
end


# Configuration
START_MODULE = "hellman"
TEST_MODULE = "TEST MODULE NOT DEFINED"

# No Need to change
PWD = Pathname(".").realpath
INCLUDE = "include"
ERLC_FLAGS = "-I#{INCLUDE} +warn_unused_vars +warn_unused_import"

SRC = FileList['src/**/*.erl']
OBJ = SRC.pathmap("%{src,ebin}X.beam")
CLEAN.include(['**/*.dump'])
CLOBBER.include(['**/*.beam'])

directory 'ebin'

rule ".beam" =>  ["%{ebin,src}X.erl"] do |t|
 sh *%W{erlc -pa ebin -W #{ERLC_FLAGS} -o ebin #{t.source}}
end

desc "Compile all"
task :compile => ['ebin'] + OBJ

desc "Open up a shell"
task :shell => [:compile] do
   sh *%W{erl -sname #{START_MODULE} -pa #{PWD + 'ebin'}}
end


desc "Open up a shell and run #{START_MODULE}:start()"
task :run => [:compile] do
   sh *%W{erl -sname #{START_MODULE} -pa #{PWD + 'ebin'} -run #{START_MODULE} start}
end

desc "Run Unit Tests"
task :test do
 sh *%W{erl -noshell -s #{TEST_MODULE} test -s init stop}
end

task :default => :compile

Happy jakin,
Aureliano.

Compilando LaTeX con rake

En el laburo estoy escribiendo un paper (es parte de las cosas que tengo que hacer como investigador en seguridad informática) y, como soy un geek que se precia, lo estoy escribiendo en LaTeX.

El temita es que las figuras que tiene el paper las hice en MS Visio y que quiero tener un script automático para generar el .dvi a partir del .tex, el .bib y los archivos de Visio. Pero LaTeX no acepta archivos de Visio como imágenes, solo .eps (encapsulated postscript) y Visio a lo sumo escupe .wmf. Así que instalé el wmf2eps y entonces tuve una idea, ¿por qué no generar todo usando rake y uso win32ole para hacer automation con el Visio?.

Este es el resultado (que anda) del rakefile que uso para generar el paper:

require 'rake/clean'
require 'win32ole'

VIS = FileList['*.vsd']
EPS = VIS.ext('eps')
MAIN = "paper.tex"
DVI = "paper.dvi"
BIB = "paper.bib"

CLEAN.include(FileList["*.wmf", "*.aux", "*.bbl", "*.blg", "*.log"] )
CLOBBER.include(FileList[DVI], VIS.ext("eps"))

def windows_name(file)
  File.expand_path(file).gsub("/","\\").gsub(" ", "\\ ")
end

def visio()
  begin
    return WIN32OLE.connect("visio.application"), false
  rescue WIN32OLERuntimeError # Visio is not running
    return WIN32OLE.new("visio.application"), true
  end
end

def open_doc(visio, filename) 
  begin
    return visio.Documents(filename), false
  rescue WIN32OLERuntimeError # file not open
    return visio.Documents.open(filename), true
  end
end

def latex
  sh "latex", "-halt-on-error", MAIN do 
    |ok, res|
    unless ok
      puts "Error compiling LaTeX file (status=#{res.exitstatus})\n"
      exit
    end
  end
end

def bibtex
  sh "bibtex", "paper" do 
    |ok, res|
    unless ok
      puts "Error compiling bibtex file (status=#{res.exitstatus})\n"
      exit
    end
  end
end

file DVI => EPS + [MAIN, BIB] do
  latex
  bibtex
  latex
  latex
end

rule '.wmf' => '.vsd' do
  |t|
  visio_filename = windows_name(t.source)
  wmf_filename = windows_name(t.name)
  visio, close_visio = visio()
  document, close_document = open_doc(visio, visio_filename)
  document.Pages(1).Export(wmf_filename)
  document.Close if close_document
  visio.Quit if close_visio
end

rule '.eps' => '.wmf' do
  |t|
  wmf_filename = windows_name(t.source)
  dirname = windows_name( File.dirname(t.source) )
  sh "wmf2eps\\wmf2eps -o #{dirname} #{wmf_filename}"
end

desc "Generates dvi for paper"
task :dvi => DVI

desc "Generates images for paper from Visio files"
task :images => EPS

desc "Generates images for paper from Visio files"
task :default => :images

Espero que les sirva esto, y que ruby se vaya acercando a la academia.

Happy hacking,
Aureliano.