ileitch-erbal 0.0.2

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Ian Leitch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,73 @@
+= Erbal: Very small, very fast Ragel/C based ERB parser
+
+== Intro
+
+Erbal is a lightweight ERB parser based on the Ragel State Machine Compiler (http://www.complang.org/ragel/) and written in C. It's very fast.
+
+Please note that Erbal isn't intended as a full replacement for the ERB implementation that ships with Ruby. Erbal only implements parsing of the following tags:
+
+  <%, <%=, <%#, -%>, %>
+  
+This is to keep Erbal very simple and very fast. If there's a good case for implementing more features from ERB and it doesn't impact performance or add much complexity then I'll consider it. Personally I've never needed anything more.
+
+== Using Erbal
+
+  require 'erbal'
+  e = Erbal.new("<% a=1 -%> a is: <%= a -%>", "@output_buffer")
+  src = e.parse
+  eval(src)
+  
+== Rails
+
+In your after_initialize block in config/environment.rb add:
+
+  require 'erbal/rails'
+  ActionView::Template.register_template_handler :erb, ErbalTemplateHandler
+
+== Benchmarks
+
+This benchmark was performed on a MacBook Pro with a 2.4Ghz Intel Core 2 Duo and 4GB 667Mhz DDR2 SDRAM. Running Mac OS X 10.6 (Snow Leopard). The code to run it is located in benchmark/bench.rb
+
+Summary:
+
+Erbal is 14.6x faster than Ruby's ERB and 7.5x faster than Erubis.
+
+Details:
+
+Ruby: 1.8.7 (2009-06-12 patchlevel 174) [i686-darwin10]
+Erubis: 2.6.5 using Erubis::FastEruby.
+Erbal: 0.0.2
+
+  => Warming up.... done
+  => 10000 runs repeated 6 times
+
+  => Erb:
+   1) 13.01
+   2) 13.00
+   3) 13.01
+   4) 13.04
+   5) 13.13
+   6) 13.23
+  => Average: 13.07
+  
+  => Erbal:
+   1) 0.90
+   2) 0.89
+   3) 0.89
+   4) 0.90
+   5) 0.89
+   6) 0.89
+  => Average: 0.89
+  
+  => Erubis:
+   1) 6.63
+   2) 6.67
+   3) 6.69
+   4) 6.71
+   5) 6.72
+   6) 6.75
+  => Average: 6.70
+
+== Credits
+
+Many thanks to Adrian Thurston for writing the Ragel State Machine Compiler (http://www.complang.org/ragel/)!

data/Rakefile

@@ -0,0 +1,12 @@
+RUBY_1_9 = RUBY_VERSION =~ /^1\.9/
+WIN      = (RUBY_PLATFORM =~ /mswin|cygwin/)
+SUDO     = (WIN ? "" : "sudo")
+
+require 'rake'
+require 'rake/clean'
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+task :default => :spec
+
+ext_task :erbal

data/benchmark/bench.rb

@@ -0,0 +1,57 @@
+require 'erb'
+require 'rubygems'
+require 'erubis'
+require File.expand_path(File.dirname(__FILE__)) + '/../lib/erbal'
+
+RUNS = 10000
+REPEAT = 6
+SRC = File.read('sample.erb')
+
+class Benchmark
+  def self.run(runs, repeat, warmup=false)
+    puts "\n=> #{self.name.split('Benchmark').first}:" unless warmup
+    times = []
+    repeat.times do |i|
+      total = 0
+      runs.times do
+        start = Time.now
+        parse
+        total += Time.now-start
+      end
+      times << total
+      puts " #{i+1}) #{sprintf("%.2f", total)}" unless warmup
+    end
+    unless warmup
+      puts "=> Average: #{sprintf("%.2f", times.inject(0){|c, n| c += n} / times.size)}"
+    end
+  end
+end
+
+class ErbalBenchmark < Benchmark
+  def self.parse
+    Erbal.new(SRC, "@output").parse
+  end
+end
+
+class ErbBenchmark < Benchmark
+  def self.parse
+    ::ERB.new(SRC, nil, '-', '@output')
+  end
+end
+
+class ErubisBenchmark < Benchmark
+  def self.parse
+    Erubis::FastEruby.new.convert(SRC)
+  end
+end
+
+parsers = [ErbBenchmark, ErbalBenchmark, ErubisBenchmark]
+
+$stdout.write("=> Warming up.... ")
+$stdout.flush
+parsers.each do |b|
+  b.run(RUNS, 1, true)
+end
+puts "done"
+puts "=> #{RUNS} runs repeated #{REPEAT} times"
+parsers.map {|b| b.run(RUNS, REPEAT)}

data/benchmark/sample.erb

@@ -0,0 +1,24 @@
+Lorem ipsum dolor sit amet, <% consectetur adipisicing elit -%>, sed do eiusmod tempor incididunt ut labore et dolore magna <%= aliqua -%>.
+<%= Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
+reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. %>
+<% Excepteur sint occaecat -%> cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est <%= laborum -%>.
+
+<% Lorem %> ipsum dolor sit amet, <% consectetur %> adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+Ut enim ad minim veniam, <%# quis nostrud exercitation ullamco laboris nisi ut aliquip ex -%> ea commodo consequat. Duis aute irure dolor in
+<%= reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur -%>.
+Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim <%= id est laborum -%>.
+
+<%= Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. -%>
+<% Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. %>
+<%= Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. %>
+<%#= Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. -%>
+
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, <% sed do eiusmod tempor incididunt ut -%> labore et dolore magna aliqua.
+Ut enim ad minim veniam, quis nostrud <%=%> exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+Duis aute irure dolor in reprehenderit in -%> <% voluptate velit esse cillum dolore eu fugiat nulla pariatur.
+Excepteur sint occaecat cupidatat non proident, sunt -%> in culpa qui officia deserunt mollit <%= anim id est laborum -%>.
+
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+Ut enim ad minim veniam, <% quis -%> nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+Duis aute irure dolor in reprehenderit in <%= voluptate velit -%> esse cillum dolore eu fugiat nulla pariatur.
+Excepteur sint occaecat cupidatat non proident, sunt in culpa <%= qui -%> <%= officia -%> <%= deserunt -%> <%= mollit -%> <%= anim -%> <%= id est laborum. -%>

data/ext/erbal/erbal.c

@@ -0,0 +1,41 @@
+#include "ruby.h"
+#include "parser.h"
+
+static VALUE cErbal;
+
+void rb_erbal_free(void *data) {
+  if(data) {
+    free(data);
+  }
+}
+
+VALUE rb_erbal_alloc(VALUE klass) {
+  erbal_parser *parser = ALLOC_N(erbal_parser, 1);
+  VALUE obj = Data_Wrap_Struct(klass, NULL, rb_erbal_free, parser);
+  return obj;
+}
+
+VALUE rb_erbal_initialize(VALUE self, VALUE str, VALUE buffer) {
+  Check_Type(str, T_STRING);
+  Check_Type(buffer, T_STRING);
+  erbal_parser *parser = NULL;
+  Data_Get_Struct(self, erbal_parser, parser);
+  parser->buffer = buffer;
+  parser->str = str;
+  return self;
+}
+
+VALUE rb_erbal_parse(VALUE self) {
+  erbal_parser *parser = NULL;
+  Data_Get_Struct(self, erbal_parser, parser);
+  erbal_parser_init(parser);
+  erbal_parser_exec(parser);
+  return parser->src;
+}
+
+void Init_erbal() {
+  cErbal = rb_define_class("Erbal", rb_cObject);
+  rb_define_alloc_func(cErbal, rb_erbal_alloc);
+  rb_define_method(cErbal, "initialize", rb_erbal_initialize, 2);
+  rb_define_method(cErbal, "parse", rb_erbal_parse, 0);
+}

data/ext/erbal/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile("erbal")

data/ext/erbal/parser.c

@@ -0,0 +1,232 @@
+
+#line 1 "parser.rl"
+#include <stdio.h>
+#include "parser.h"
+
+
+#line 15 "parser.rl"
+
+
+
+#line 12 "parser.c"
+static const int erbal_parser_start = 1;
+static const int erbal_parser_first_final = 1;
+static const int erbal_parser_error = -1;
+
+static const int erbal_parser_en_main = 1;
+
+
+#line 18 "parser.rl"
+
+static char *ts, *te, *p, *pe, *eof;
+static int act, cs;
+
+inline void erbal_parser_tag_open(erbal_parser *parser) {
+  parser->open = 1;
+  if (parser->mark) {
+    parser->mark = 0;
+    rb_str_buf_cat(parser->src, "\");", 3);
+  }
+}
+
+inline void erbal_parser_tag_open_with_output(erbal_parser *parser) {
+  erbal_parser_tag_open(parser);
+  parser->output = 1;
+  rb_str_concat(parser->src, parser->buffer);
+  rb_str_buf_cat(parser->src, ".concat((", 9);
+}
+
+inline void erbal_parser_tag_open_with_comment(erbal_parser *parser) {
+  erbal_parser_tag_open(parser);
+  parser->comment = 1;
+}
+
+inline void erbal_parser_any(erbal_parser *parser) {
+  if (parser->comment) {
+    return;
+  }
+
+  if (parser->open) {
+    rb_str_buf_cat(parser->src, p, 1);
+  } else {
+    if (!parser->mark) {
+      parser->mark = 1;
+      rb_str_concat(parser->src, parser->buffer);
+      rb_str_buf_cat(parser->src, ".concat(\"", 9);
+    }
+    if (p[0] == '"') {
+      rb_str_buf_cat(parser->src, "\\\"", 2);
+    } else {
+      rb_str_buf_cat(parser->src, p, 1);
+    }
+  }
+}
+
+inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
+  erbal_parser_tag_close(parser);
+  if (p[1] == '\n') {
+    p++;
+  }
+}
+
+inline void erbal_parser_tag_close(erbal_parser *parser) {
+  parser->open = 0;
+  if (parser->output) {
+    parser->output = 0;
+    rb_str_buf_cat(parser->src, ").to_s);", 8);
+  } else if (!parser->comment) {
+    rb_str_buf_cat(parser->src, ";", 1);
+  }
+  parser->comment = 0;
+}
+
+inline void erbal_parser_finish(erbal_parser *parser) {
+  if (parser->mark) {
+    rb_str_buf_cat(parser->src, "\");", 3);
+  }
+  rb_str_concat(parser->src, parser->buffer);
+}
+
+void erbal_parser_init(erbal_parser *parser) {
+  parser->mark = 0;
+  parser->open = 0;
+  parser->output = 0;
+  parser->comment = 0;
+  parser->src = rb_str_dup(parser->buffer);
+  rb_str_buf_cat(parser->src, "=\"\";", 4);
+  
+#line 99 "parser.c"
+	{
+	cs = erbal_parser_start;
+	ts = 0;
+	te = 0;
+	act = 0;
+	}
+
+#line 96 "parser.rl"
+}
+
+void erbal_parser_exec(erbal_parser *parser) {
+  p = RSTRING(parser->str)->ptr;
+  pe = p + strlen(p);
+  
+#line 114 "parser.c"
+	{
+	if ( p == pe )
+		goto _test_eof;
+	switch ( cs )
+	{
+tr0:
+#line 11 "parser.rl"
+	{{p = ((te))-1;}{ erbal_parser_any(parser); }}
+	goto st1;
+tr1:
+#line 12 "parser.rl"
+	{te = p+1;{ erbal_parser_tag_close_with_trim(parser); }}
+	goto st1;
+tr2:
+#line 11 "parser.rl"
+	{te = p+1;{ erbal_parser_any(parser); }}
+	goto st1;
+tr6:
+#line 11 "parser.rl"
+	{te = p;p--;{ erbal_parser_any(parser); }}
+	goto st1;
+tr7:
+#line 13 "parser.rl"
+	{te = p+1;{ erbal_parser_tag_close(parser); }}
+	goto st1;
+tr10:
+#line 8 "parser.rl"
+	{te = p;p--;{ erbal_parser_tag_open(parser); }}
+	goto st1;
+tr11:
+#line 9 "parser.rl"
+	{te = p+1;{ erbal_parser_tag_open_with_comment(parser); }}
+	goto st1;
+tr12:
+#line 10 "parser.rl"
+	{te = p+1;{ erbal_parser_tag_open_with_output(parser); }}
+	goto st1;
+st1:
+#line 1 "parser.rl"
+	{ts = 0;}
+	if ( ++p == pe )
+		goto _test_eof1;
+case 1:
+#line 1 "parser.rl"
+	{ts = p;}
+#line 160 "parser.c"
+	switch( (*p) ) {
+		case 37: goto st2;
+		case 45: goto tr4;
+		case 60: goto st4;
+	}
+	goto tr2;
+st2:
+	if ( ++p == pe )
+		goto _test_eof2;
+case 2:
+	if ( (*p) == 62 )
+		goto tr7;
+	goto tr6;
+tr4:
+#line 1 "parser.rl"
+	{te = p+1;}
+	goto st3;
+st3:
+	if ( ++p == pe )
+		goto _test_eof3;
+case 3:
+#line 182 "parser.c"
+	if ( (*p) == 37 )
+		goto st0;
+	goto tr6;
+st0:
+	if ( ++p == pe )
+		goto _test_eof0;
+case 0:
+	if ( (*p) == 62 )
+		goto tr1;
+	goto tr0;
+st4:
+	if ( ++p == pe )
+		goto _test_eof4;
+case 4:
+	if ( (*p) == 37 )
+		goto st5;
+	goto tr6;
+st5:
+	if ( ++p == pe )
+		goto _test_eof5;
+case 5:
+	switch( (*p) ) {
+		case 35: goto tr11;
+		case 61: goto tr12;
+	}
+	goto tr10;
+	}
+	_test_eof1: cs = 1; goto _test_eof; 
+	_test_eof2: cs = 2; goto _test_eof; 
+	_test_eof3: cs = 3; goto _test_eof; 
+	_test_eof0: cs = 0; goto _test_eof; 
+	_test_eof4: cs = 4; goto _test_eof; 
+	_test_eof5: cs = 5; goto _test_eof; 
+
+	_test_eof: {}
+	if ( p == eof )
+	{
+	switch ( cs ) {
+	case 2: goto tr6;
+	case 3: goto tr6;
+	case 0: goto tr0;
+	case 4: goto tr6;
+	case 5: goto tr10;
+	}
+	}
+
+	}
+
+#line 102 "parser.rl"
+  erbal_parser_finish(parser);
+}

data/ext/erbal/parser.h

@@ -0,0 +1,19 @@
+#ifndef erbal_parser_h
+#define erbal_parser_h
+
+#include "ruby.h"
+
+typedef struct erbal_parser {
+  int output, open, mark, comment;
+  VALUE str, src, buffer;
+} erbal_parser;
+
+inline void erbal_parser_tag_open(erbal_parser*);
+inline void erbal_parser_tag_open_with_comment(erbal_parser*);
+inline void erbal_parser_tag_open_with_output(erbal_parser*);
+inline void erbal_parser_any(erbal_parser*);
+inline void erbal_parser_tag_close(erbal_parser*);
+inline void erbal_parser_tag_close_with_trim(erbal_parser*);
+inline void erbal_parser_finish(erbal_parser*);
+
+#endif

data/ext/erbal/parser.rl

@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include "parser.h"
+
+%%{
+  machine erbal_parser;
+
+  main := |*
+    '<%'  => { erbal_parser_tag_open(parser); };
+    '<%#'  => { erbal_parser_tag_open_with_comment(parser); };
+    '<%=' => { erbal_parser_tag_open_with_output(parser); };
+    any   => { erbal_parser_any(parser); };
+    '-%>' => { erbal_parser_tag_close_with_trim(parser); };
+    '%>'  => { erbal_parser_tag_close(parser); };
+  *|;
+}%%
+
+%% write data;
+
+static char *ts, *te, *p, *pe, *eof;
+static int act, cs;
+
+inline void erbal_parser_tag_open(erbal_parser *parser) {
+  parser->open = 1;
+  if (parser->mark) {
+    parser->mark = 0;
+    rb_str_buf_cat(parser->src, "\");", 3);
+  }
+}
+
+inline void erbal_parser_tag_open_with_output(erbal_parser *parser) {
+  erbal_parser_tag_open(parser);
+  parser->output = 1;
+  rb_str_concat(parser->src, parser->buffer);
+  rb_str_buf_cat(parser->src, ".concat((", 9);
+}
+
+inline void erbal_parser_tag_open_with_comment(erbal_parser *parser) {
+  erbal_parser_tag_open(parser);
+  parser->comment = 1;
+}
+
+inline void erbal_parser_any(erbal_parser *parser) {
+  if (parser->comment) {
+    return;
+  }
+
+  if (parser->open) {
+    rb_str_buf_cat(parser->src, p, 1);
+  } else {
+    if (!parser->mark) {
+      parser->mark = 1;
+      rb_str_concat(parser->src, parser->buffer);
+      rb_str_buf_cat(parser->src, ".concat(\"", 9);
+    }
+    if (p[0] == '"') {
+      rb_str_buf_cat(parser->src, "\\\"", 2);
+    } else {
+      rb_str_buf_cat(parser->src, p, 1);
+    }
+  }
+}
+
+inline void erbal_parser_tag_close_with_trim(erbal_parser *parser) {
+  erbal_parser_tag_close(parser);
+  if (p[1] == '\n') {
+    p++;
+  }
+}
+
+inline void erbal_parser_tag_close(erbal_parser *parser) {
+  parser->open = 0;
+  if (parser->output) {
+    parser->output = 0;
+    rb_str_buf_cat(parser->src, ").to_s);", 8);
+  } else if (!parser->comment) {
+    rb_str_buf_cat(parser->src, ";", 1);
+  }
+  parser->comment = 0;
+}
+
+inline void erbal_parser_finish(erbal_parser *parser) {
+  if (parser->mark) {
+    rb_str_buf_cat(parser->src, "\");", 3);
+  }
+  rb_str_concat(parser->src, parser->buffer);
+}
+
+void erbal_parser_init(erbal_parser *parser) {
+  parser->mark = 0;
+  parser->open = 0;
+  parser->output = 0;
+  parser->comment = 0;
+  parser->src = rb_str_dup(parser->buffer);
+  rb_str_buf_cat(parser->src, "=\"\";", 4);
+  %% write init;
+}
+
+void erbal_parser_exec(erbal_parser *parser) {
+  p = RSTRING(parser->str)->ptr;
+  pe = p + strlen(p);
+  %% write exec;
+  erbal_parser_finish(parser);
+}

data/lib/erbal/rails.rb

@@ -0,0 +1,8 @@
+require 'erbal'
+
+class ErbalTemplateHandler < ActionView::TemplateHandler
+  include ActionView::TemplateHandlers::Compilable
+  def compile(template)
+    ::Erbal.new("<% __in_erb_template=true %>#{template.source}", '@output_buffer').parse
+  end
+end

data/tasks/ext.rake

@@ -0,0 +1,42 @@
+CLEAN.include %w(**/*.{o,bundle,jar,so,obj,pdb,lib,def,exp,log} ext/*/Makefile ext/*/conftest.dSYM)
+
+def ext_task(name)
+  ext_dir    = "ext/#{name}"
+  ext_bundle = "#{ext_dir}/#{name}.#{Config::CONFIG['DLEXT']}"
+  ext_files  = FileList[
+    "#{ext_dir}/*.c",
+    "#{ext_dir}/*.h",
+    "#{ext_dir}/*.rl",
+    "#{ext_dir}/extconf.rb",
+    "#{ext_dir}/Makefile",
+    "lib"
+  ]
+  
+  task "compile:#{name}" => ["#{ext_dir}/Makefile", ext_bundle]
+  task :compile => "compile:#{name}"
+  
+  file "#{ext_dir}/Makefile" => ["#{ext_dir}/extconf.rb"] do
+    cd(ext_dir) { ruby "extconf.rb" }
+  end
+
+  file ext_bundle => ext_files do
+    cd ext_dir do
+      sh(WIN ? 'nmake' : 'make')
+    end
+    cp ext_bundle, 'lib/'
+  end
+end
+
+desc "Compile the Ragel state machines"
+task :ragel do
+  Dir.chdir 'ext/erbal' do
+    target = "parser.c"
+    File.unlink target if File.exist? target
+    sh "ragel -G2 -o parser.c parser.rl"
+    raise "Failed to compile Ragel state machine" unless File.exist? target
+  end
+end
+  
+desc "Compile the extensions"
+task :compile => :ragel
+task :package => :compile

data/tasks/gem.rake

@@ -0,0 +1,54 @@
+require 'rake/gempackagetask'
+require 'yaml'
+
+WIN_SUFFIX = ENV['WIN_SUFFIX'] || 'i386-mswin32'
+ERBAL_VERSION = '0.0.2'
+
+task :clean => :clobber_package
+
+spec = Gem::Specification.new do |s|
+  s.name                  = 'erbal'
+  s.version               = ERBAL_VERSION
+  s.platform              = WIN ? Gem::Platform::CURRENT : Gem::Platform::RUBY
+  s.summary               = 
+  s.description           = "Very small, very fast Ragel/C based ERB parser"
+  s.author                = "Ian Leitch"
+  s.email                 = 'ian.leitch@systino.net'
+  s.homepage              = 'http://github.com/ileitch/erbal'
+  s.has_rdoc              = false
+
+  s.files                 = %w(COPYING CHANGELOG README.rdoc Rakefile) +
+                            Dir.glob("{lib,spec,tasks,benchmark}/**/*") + 
+                            Dir.glob("ext/**/*.{h,c,rb,rl}")
+  
+  if WIN
+    s.files              += ["lib/erbal.#{Config::CONFIG['DLEXT']}"]
+  else
+    s.extensions          = FileList["ext/**/extconf.rb"].to_a
+  end
+  
+  s.require_path          = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+namespace :gem do
+  desc "Update the gemspec for GitHub's gem server"
+  task :github do
+    File.open("erbal.gemspec", 'w') { |f| f << YAML.dump(spec) }
+  end  
+end
+
+task :install => [:clean, :clobber, :ragel, :compile, :package] do
+  sh "#{SUDO} #{gem} install pkg/#{spec.full_name}.gem"
+end
+
+task :uninstall => :clean do
+  sh "#{SUDO} #{gem} uninstall -v #{ERBAL_VERSION} -x erbal"
+end
+
+def gem
+  RUBY_1_9 ? 'gem19' : 'gem'
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: ileitch-erbal
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Ian Leitch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-01 21:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Very small, very fast Ragel/C based ERB parser
+email: ian.leitch@systino.net
+executables: []
+
+extensions: 
+- ext/erbal/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- COPYING
+- CHANGELOG
+- README.rdoc
+- Rakefile
+- lib/erbal
+- lib/erbal/rails.rb
+- tasks/ext.rake
+- tasks/gem.rake
+- tasks/spec.rake
+- benchmark/bench.rb
+- benchmark/sample.erb
+- ext/erbal/parser.h
+- ext/erbal/erbal.c
+- ext/erbal/parser.c
+- ext/erbal/extconf.rb
+- ext/erbal/parser.rl
+has_rdoc: true
+homepage: http://github.com/ileitch/erbal
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Very small, very fast Ragel/C based ERB parser
+test_files: []
+