jarrett-quarto 1.3.0 → 1.4.0

data/README

@@ -1,9 +1,14 @@
 Quarto is a Ruby framework for generating collections of documents from XML. Potential applications
-include web sites and e-books. It's built on top of ERB and REXML.
+include web sites and e-books. It's built on top of ERB and REXML. It works as a standalone
+application and inside Rails.
 
 Quarto was built with HTML output in mind, but there's nothing to prevent you from outputting
 to any other format. You could even output to an interpolated scripting language like PHP.
 
+As of the inception of Quarto, there is no cross-platform XSLT gem. So, Quarto comes with its
+own alternative to XSLT in the form of the Tranformer class and the TransformationHelper
+module.
+
 Why Quarto?
 ===========
 

data/Rakefile

@@ -10,7 +10,7 @@ begin
 		gemspec.authors = ['Jarrett Colby']
 		gemspec.files = FileList['[A-Z]*', '{bin,lib,test}/**/*']
 		gemspec.executables = 'quarto'
-		gemspec.add_dependency('activesupport', '>= 2.3.2')
+		gemspec.add_dependency('activesupport', '~> 2.3.2')
 	end
 rescue LoadError
 	puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"

data/VERSION

@@ -1 +1 @@
-1.3.0
+1.4.0

data/lib/quarto/element_wrapper.rb

@@ -124,8 +124,15 @@ module Quarto
 				end
 				if element_attrs = self.class.read_inheritable_attribute(:element_attrs)
 					element_attrs.each do |el_name|
-						raise ArgumentError, "Expected <#{@element.name}> to have child <#{el_name}>" if @element.elements[el_name.to_s].nil?
-						@attributes[el_name.to_sym] = typecast_text(@element.elements[el_name.to_s].text)
+						if child_el = @element.elements[el_name.to_s]
+							if child_el.elements.empty?
+								@attributes[el_name.to_sym] = typecast_text(child_el.text)
+							else
+								@attributes[el_name.to_sym] = child_el
+							end
+						else
+							@attributes[el_name.to_sym] = nil
+						end
 					end
 				end
 				if text_attr = self.class.read_inheritable_attribute(:text_attr)

data/lib/quarto/generator.rb

@@ -41,7 +41,7 @@ module Quarto
 	# This class responds to all the directives that are available for use within
 	# a generate.rb file.
 	class Generator
-		include UrlHelper
+		include Quarto::UrlHelper
 		
 		# Sets the name of the default layout file in the layouts directory. If
 		# default_layout isn't specified, the default layout is the first file matching <tt>default.*</tt>.
@@ -130,7 +130,7 @@ module Quarto
 		def render_to_s(template, locals, options = {})
 			require urls_file_path
 			
-			mixins = [Quarto::ProjectUrls, Quarto::RailsHelper, Quarto::UrlHelper]
+			mixins = [Quarto::ProjectUrls, Quarto::RailsHelper, Quarto::UrlHelper, Quarto::TransformationHelper]
 			
 			page_template_path = "#{@project_path}/pages/#{template}"
 			page_template = ERB.new(File.read(page_template_path))

data/lib/quarto/html_transformer.rb

@@ -0,0 +1,103 @@
+module Quarto
+	class HtmlTransformer < Transformer
+		HTML_ELEMENTS = %w(
+			a
+			abbr
+			acronym
+			address
+			applet
+			area
+			b
+			base
+			basefont
+			bdo
+			big
+			blockquote
+			body
+			br
+			button
+			caption
+			center
+			cite
+			code
+			col
+			colgroup
+			dd
+			del
+			dfn
+			dir
+			div
+			dl
+			dt
+			em
+			fieldset
+			font
+			form
+			frame
+			frameset
+			h1
+			h2
+			h3
+			h4
+			h5
+			h6
+			head
+			hr
+			html
+			i
+			iframe
+			img
+			input
+			ins
+			isindex
+			kbd
+			label
+			legend
+			li
+			link
+			map
+			menu
+			meta
+			noframes
+			noscript
+			object
+			ol
+			optgroup
+			option
+			p
+			param
+			pre
+			q
+			s
+			samp
+			script
+			select
+			small
+			span
+			strike
+			strong
+			style
+			sub
+			sup
+			table
+			tbody
+			td
+			textarea
+			tfoot
+			th
+			thead
+			title
+			tr
+			tt
+			u
+			ul
+			var
+		)
+		
+		protected
+		
+		def literal?(element)
+			HTML_ELEMENTS.include?(element.name)
+		end
+	end
+end

data/lib/quarto/transformation_helper.rb

@@ -0,0 +1,29 @@
+module Quarto
+	module TransformationHelper
+		# Tranforms the children of +element+ using
+		# an instance of +transformer_class+ and returns
+		# a string representation of the result.
+		#
+		# +transformer_class+ must be a subclass of
+		# Quarto::Transformer or <tt>nil</tt>. If it's
+		# <tt>nil</tt> (which is the default), the default
+		# subclass will be used. The default subclass is set
+		# in <tt>generate.rb</tt> as follows:
+		#
+		#   config(:default_transformer_class, YourSubclass)
+		#
+		# If you do not specify a default class,
+		# <tt>HtmlTransformer</tt> will be used.
+		def transform_xml(element, transformer_class = Quarto::HtmlTransformer)
+			raise ArgumentError, "Expected REXML::Element but got #{element.inspect}" unless element.is_a?(REXML::Element)
+			class_error = "Expected subclass of Tranformer but got #{transformer_class.inspect}"
+			raise ArgumentError, class_error unless transformer_class.is_a?(Class)
+			klass = transformer_class
+			while klass != Quarto::Transformer and klass != Object
+				klass = klass.superclass
+			end
+			raise ArgumentError, class_error unless Quarto::Transformer == klass
+			transformer_class.new.transform(element)
+		end
+	end
+end

data/lib/quarto/transformer.rb

@@ -0,0 +1,143 @@
+module Quarto
+	# This abstract base class is a substitute for XSLT. Its
+	# <tt>transform</tt> method takes a single
+	# <tt>REXML::Element</tt> and applies rules defined in
+	# the subclass.
+	#
+	# To define those rules, you subclass Transformer and
+	# write methods to handle each element type. For example:
+	#
+	#   class MyTranformer < Quarto::Transformer
+	#     # This method will handle all <book> elements
+	#     def transform_book(book_element)
+	#        # Return whatever string you like
+	#        # raise_on_unrecognized_element is provided
+	#        # so that you can pass it to recursive_transform
+	#        # if necessary.
+	#     end
+	#   end
+	class Transformer
+		# Macro to define the <tt>literal?</tt> method. Accepts
+		# one or more element names.
+		#
+		# Example:
+		#
+		#   class MyTransformer < Quarto::Transformer
+		#     literals 'div', 'p', 'a'
+		#   end
+		#
+		# The above is equivalent to:
+		#
+		#   class MyTransformer < Quarto::Transformer
+		#     def literal?(element)
+		#       ['div', 'p', 'a'].include?(element.name)
+		#     end
+		#   end 
+		def self.literals(*args)
+			class_eval(%Q(
+				def literal?(element)
+					[#{args.collect { |e| "'#{e}'" }.join(',')}].include?(element.name)
+				end
+			))
+		end
+		
+		# Recursively applies the transformation rules
+		# you've defined to +element+ and its children,
+		# returning the results as a string. Depending
+		# on the rules you've set up, the result may
+		# be XML or something else altogether.
+		#
+		# +element+ must be a <tt>REXML::Element</tt>.
+		#
+		# By default, unrecognized elements (and all their
+		# descendants) will be ommited from the result tree.
+		#
+		# However, you can cause these unrecognized elements to
+		# raise an exception by setting +raise_on_unrecognized_element+
+		# to <tt>true</tt>.
+		def transform(element, raise_on_unrecognized_element = false)
+			raise ArgumentError, "Expected REXML::Element but got #{element.inspect}" unless element.is_a?(REXML::Element)
+			if element.is_a?(REXML::Document)
+				recursive_transform(element.root, raise_on_unrecognized_element)
+			else
+				recursive_transform(element, raise_on_unrecognized_element)
+			end
+		end
+		
+		protected
+		
+		def content_tag(tag_name, *args) # :nodoc:
+			if args.last.is_a?(Hash)
+				attributes = args.pop
+			else
+				attributes = {}
+			end
+			if args.empty?
+				if block_given?
+					contents = yield
+				else
+					contents = nil
+				end
+			else
+				contents = args[0]
+			end
+			output = "<#{tag_name}"
+			attributes.each do |attr, value|
+				output << " #{attr}=\"#{value}\""
+			end
+			if contents.nil? or contents.empty?
+				output << '/>'
+			else
+				output << ">#{contents}</#{tag_name}>"
+			end
+		end
+		
+		# This method is meant to be overriden in subclasses. The
+		# default implementation always returns false.
+		#
+		# When <tt>tranform</tt> is called, each descendant element
+		# is passed to <tt>literal?</tt>. If it returns true,
+		# the descdant is added to the result tree with the same
+		# tag. If not, the <tt>Transformer</tt> will look for a
+		# custom tranform method for that element. If none is found,
+		# what happens next depends on the value of
+		# <tt>raise_on_unrecognized_element</tt> in <tt>transform</tt>.
+		# If it's true, an exception will be raised. Otherwise, the
+		# element and its descendant will be ommitted from the result
+		# tree.
+		#
+		# If <tt>literal?</tt> returns true for an element,
+		# its descendant elements will not be added to the tree
+		# verbatim, but will instead be subjected to the same
+		# transformation process as everything else.
+		#
+		# See <tt>HtmlTransformer</tt> for an example implementation.
+		def literal?(element)
+			false
+		end
+		
+		# Recursively transform the +element+ and all its children,
+		# returning a string. Custom transform methods often call
+		# this method.
+		def recursive_transform(element, raise_on_unrecognized_element)
+			if element.is_a?(REXML::Element)
+				if respond_to?("transform_#{element.name}")
+					send("transform_#{element.name}", element, raise_on_unrecognized_element)
+				elsif literal?(element)
+					contents = element.children.inject('') do |result, child|
+						result + recursive_transform(child, raise_on_unrecognized_element)
+					end
+					content_tag(element.name, contents, element.attributes)
+				elsif raise_on_unrecognized_element
+					raise UnrecognizedElementError, "Unrecognized element: #{element.name}"
+				else
+					''
+				end
+			else
+				element.to_s
+			end
+		end
+	end
+	
+	class UnrecognizedElementError < RuntimeError; end
+end

data/lib/quarto.rb

@@ -15,6 +15,9 @@ require 'quarto/element_wrapper'
 require 'quarto/children'
 require 'quarto/rendering'
 require 'quarto/generator'
+require 'quarto/transformer'
+require 'quarto/html_transformer'
+require 'quarto/transformation_helper'
 require 'quarto/init_project'
 
 # Quarto is a Ruby framework for generating collections of documents from XML. Potential applications

data/quarto.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{quarto}
-  s.version = "1.3.0"
+  s.version = "1.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jarrett Colby"]
-  s.date = %q{2009-06-10}
+  s.date = %q{2009-06-15}
   s.default_executable = %q{quarto}
   s.description = %q{Quarto is a Ruby framework for generating collections of documents from XML. It steps in where XSLT just won't cut it. Potential applications include web sites and e-books. It's built on top of ERB and REXML.}
   s.email = %q{jarrett@uchicago.edu}
@@ -24,14 +24,16 @@ Gem::Specification.new do |s|
      "lib/quarto/config.rb",
      "lib/quarto/element_wrapper.rb",
      "lib/quarto/generator.rb",
+     "lib/quarto/html_transformer.rb",
      "lib/quarto/inheritable_attributes.rb",
      "lib/quarto/init_project.rb",
      "lib/quarto/rails_helper.rb",
      "lib/quarto/rendering.rb",
+     "lib/quarto/transformation_helper.rb",
+     "lib/quarto/transformer.rb",
      "lib/quarto/url_helper.rb",
      "lib/quarto/xml_doc.rb",
-     "quarto.gemspec",
-     "test.rb"
+     "quarto.gemspec"
   ]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/jarrett/quarto}
@@ -45,6 +47,7 @@ Gem::Specification.new do |s|
      "spec/generator_spec.rb",
      "spec/init_project_spec.rb",
      "spec/matchers/file_matchers.rb",
+     "spec/matchers/rexml_matchers.rb",
      "spec/rendering_spec.rb",
      "spec/sample_models.rb",
      "spec/sample_project/generate.rb",
@@ -55,6 +58,8 @@ Gem::Specification.new do |s|
      "spec/sample_project/models/product.rb",
      "spec/sample_project/urls.rb",
      "spec/spec_helper.rb",
+     "spec/transformation_helper_spec.rb",
+     "spec/transformer_spec.rb",
      "spec/url_helper_spec.rb"
   ]
 
@@ -63,11 +68,11 @@ Gem::Specification.new do |s|
     s.specification_version = 2
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activesupport>, [">= 2.3.2"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 2.3.2"])
     else
-      s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+      s.add_dependency(%q<activesupport>, ["~> 2.3.2"])
     end
   else
-    s.add_dependency(%q<activesupport>, [">= 2.3.2"])
+    s.add_dependency(%q<activesupport>, ["~> 2.3.2"])
   end
 end

data/spec/element_wrapper_spec.rb

@@ -7,7 +7,7 @@ describe Quarto::ElementWrapper::Base do
 		@xml = Quarto.xml_doc
 	end
 	
-	context 'wrapping an element with attributes' do
+	context 'wrapping an element with attributes and child elements' do
 		before :each do
 			@element = @xml.elements['companies/company']
 			@company = Company.new(@element)
@@ -22,6 +22,11 @@ describe Quarto::ElementWrapper::Base do
 			@company.name.should == '37Signals'
 		end
 		
+		it 'should return a REXML::Element if an elemement_attr contains markup' do
+			company = Company.find(:first, :xpath => "//company[name='Mega-lo-Mart']")
+			company.description.should be_a(REXML::Element)
+		end
+		
 		it 'should define methods from XML attributes by default' do
 			@company.should respond_to(:reality)
 			@company.reality.should == 'real'

data/spec/init_project_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'fileutils'
 
 describe Quarto do
-	include FileMatchers
+	include Quarto::FileMatchers
 	
 	context '.init_project on an empty directory' do
 		before :all do

data/spec/matchers/file_matchers.rb

@@ -1,20 +1,22 @@
-module FileMatchers
-	class ExistOnDisk
-		def matches?(target)
-			@target = File.expand_path(target)
-			File.exists?(@target)
+module Quarto
+	module FileMatchers
+		class ExistOnDisk
+			def matches?(target)
+				@target = File.expand_path(target)
+				File.exists?(@target)
+			end
+			
+			def failure_message
+				"Expected file #{@target} to exist"
+			end
+			
+			def negative_failure_message
+				"Expected file #{@target} not to exist"
+			end
 		end
 		
-		def failure_message
-			"Expected file #{@target} to exist"
+		def exist_on_disk
+			ExistOnDisk.new
 		end
-		
-		def negative_failure_message
-			"Expected file #{@target} not to exist"
-		end
-	end
-	
-	def exist_on_disk
-		ExistOnDisk.new
 	end
 end

data/spec/matchers/rexml_matchers.rb

@@ -0,0 +1,65 @@
+module Quarto
+	module REXMLMatchers
+		class HaveElement
+			def initialize(element_name, options)
+				@element_name = element_name
+				@options = options
+			end
+			
+			def matches?(target)
+				@target = target
+				!@target.find_first_recursive { |node| node_matches?(node) }.nil?
+			end
+			
+			def failure_message
+				"Expected element '#{element_desc}' to be in:\n\n#{@target.to_s}"
+			end
+			
+			def negative_failure_message
+				"Expected element '#{element_desc}' not to be in:\n\n#{@target.to_s}"
+			end
+			
+			protected
+			
+			def element_desc
+				desc = @element_name
+				if @options.has_key?(:attributes)
+					desc << " with attributes: #{@options[:attributes].inspect}"
+					if @options.has_key?(:text)
+						desc << " and text: '#{@options[:text]}'"
+					end
+				else
+					if @options.has_key?(:text)
+						desc << " with text: '#{@options[:text]}'"
+					end
+				end
+				desc
+			end
+			
+			def node_matches?(node)
+				if node.name != @element_name
+					return false
+				end
+				if @options.has_key?(:attributes) and rexml_attrs_to_hash(node.attributes) != @options[:attributes]
+					return false
+				end
+				if @options.has_key?(:text) and node.text != @options[:text]
+					return false
+				end
+				true
+			end
+			
+			def rexml_attrs_to_hash(rexml_attrs)
+				hash = {}
+				rexml_attrs.each do |attr_name, value|
+					hash[attr_name] = value
+				end
+				hash
+			end
+		end
+		
+		def have_element(element_name, options = {})
+			HaveElement.new(element_name, options)
+		end
+	end
+end

data/spec/sample_project/models/company.rb

@@ -1,5 +1,5 @@
 class Company < Quarto::ElementWrapper::Base
-	element_attrs :name, :industry
+	element_attrs :name, :industry, :description
 	
 	children :employees
 	

data/spec/transformation_helper_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Quarto::TransformationHelper do
+	include Quarto::TransformationHelper
+	
+	context '#tranform_xml' do
+		before :each do
+			@html = REXML::Document.new(%Q(
+				<div>
+					<p>Foo</p>
+					<p><a href="http://example.com">Bar</a></p>
+				</div>
+			))
+		end
+		
+		it 'should return a string' do
+			transform_xml(@html).should be_a(String)
+			transform_xml(@html.root).should be_a(String)
+		end
+		
+		it 'should raise if passed anything other than a REXML::Element' do
+			lambda { transform_xml(nil) }.should raise_error(ArgumentError, 'Expected REXML::Element but got nil')
+			lambda { transform_xml('foo') }.should raise_error(ArgumentError, 'Expected REXML::Element but got "foo"')
+		end
+		
+		context 'without transformer_class given' do
+			it 'should use HtmlTransformer' do
+				t = Quarto::HtmlTransformer.new
+				Quarto::HtmlTransformer.should_receive(:new).and_return(t)
+				transform_xml(@html)
+			end
+		end
+	end
+end

data/spec/transformer_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Quarto::Transformer do
+	include Quarto::REXMLMatchers
+	
+	context '#transform' do
+		before :each do
+			@xml = %q(
+				<doc>
+					<div>
+						<p>Foo</p>
+						<p>Bar</p>
+						
+						<book>
+							<title>Foobar</title>
+							<author>Baz</author>
+							<cover_url>http://example.com/foobar.jpeg</cover_url>
+						</book>
+					</div>
+				</doc>
+			)
+			@doc = REXML::Document.new(@xml)
+			
+			class TestTransformer < Quarto::Transformer
+				def literal?(element)
+					['doc', 'div', 'p'].include?(element.name)
+				end
+			end
+			
+			@t = TestTransformer.new
+		end
+		
+		after :each do
+			Object.class_eval do
+				remove_const :TestTransformer
+			end
+		end
+		
+		it 'should return a string' do
+			@t.transform(@doc).should be_a(String)
+			@t.transform(@doc.root).should be_a(String)
+			@t.transform(REXML::Document.new('')).should be_a(String)
+		end
+		
+		it 'should raise if passed anything other than a REXML::Element' do
+			lambda { @t.transform(nil) }.should raise_error(ArgumentError, 'Expected REXML::Element but got nil')
+			lambda { @t.transform('foo') }.should raise_error(ArgumentError, 'Expected REXML::Element but got "foo"')
+		end
+		
+		it 'should not transform elements that lack custom transform methods and for which literal? returns true' do
+			result = REXML::Document.new(@t.transform(@doc))
+			result.should have_element('doc')
+			result.should have_element('div')
+			result.should have_element('p', :text => 'Foo')
+			result.should have_element('p', :text => 'Bar')
+		end
+		
+		it 'should ignore elements that lack custom transform methods and for which literal? returns false' do
+			result = REXML::Document.new(@t.transform(@doc))
+			['book', 'title', 'author' 'cover_url'].each do |el|
+				result.should_not have_element(el)
+			end
+		end
+		
+		it 'should use custom transform methods' do
+			begin
+				class CustomizedTestTransformer < TestTransformer
+					def transform_book(book_element, raise_on_unrecognized_element)
+						%Q(
+							<div class="book">
+								<h1 class="title">#{book_element.elements['title'].text}</h1>
+								<h2 class="author">#{book_element.elements['author'].text}</h2>
+								<img src="#{book_element.elements['cover_url'].text}"/>
+							</div>
+						)
+					end
+				end
+			
+				t = CustomizedTestTransformer.new
+				result = REXML::Document.new(t.transform(@doc))
+				result.should have_element('div', :attributes => {'class' => 'book'})
+				result.should have_element('h1', :attributes => {'class' => 'title'}, :text => 'Foobar')
+				result.should have_element('h2', :attributes => {'class' => 'author'}, :text => 'Baz')
+				result.should have_element('img', :attributes => {'src' => 'http://example.com/foobar.jpeg'})
+			ensure
+				Object.class_eval do
+					remove_const :CustomizedTestTransformer
+				end
+			end
+		end
+		
+		it 'should give precedence to custom transform methods over literal?' do
+			begin
+				class CustomizedTestTransformer < TestTransformer
+					def transform_p(p_element, raise_on_unrecognized_element)
+						%Q(<div class="paragraph">#{p_element.text}</div>)
+					end
+				end
+			
+				t = CustomizedTestTransformer.new
+				result = REXML::Document.new(t.transform(@doc))
+				result.should have_element('div', :attributes => {'class' => 'paragraph'}, :text => 'Foo')
+				result.should have_element('div', :attributes => {'class' => 'paragraph'}, :text => 'Bar')
+			ensure
+				Object.class_eval do
+					remove_const :CustomizedTestTransformer
+				end
+			end				
+		end
+	end
+	
+	context '.literals' do
+		before :each do
+			class TestTransformer < Quarto::Transformer
+				literals :doc, :div, 'p'
+			end
+		end
+		
+		after :each do
+			Object.class_eval do
+				remove_const :TestTransformer
+			end
+		end
+		
+		it 'should define literal? so that it returns true for any element on the list and false for any other' do
+			t = TestTransformer.new
+			['doc', 'div', 'p'].each do |el_name|
+				t.send(:literal?, REXML::Element.new(el_name)).should == true
+			end
+			['foo', 'bar', 'baz'].each do |el_name|
+				t.send(:literal?, REXML::Element.new(el_name)).should == false
+			end
+		end
+		
+		it 'should have no effect if literal? is subsequently defined' do
+			class TestTransformer < Quarto::Transformer
+				def literal?(element)
+					false
+				end
+			end
+			
+			t = TestTransformer.new
+			['doc', 'div', 'p'].each do |el_name|
+				t.send(:literal?, REXML::Element.new(el_name)).should == false
+			end
+		end
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jarrett-quarto
 version: !ruby/object:Gem::Version 
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Jarrett Colby
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-10 00:00:00 -07:00
+date: 2009-06-15 00:00:00 -07:00
 default_executable: quarto
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -18,7 +18,7 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         version: 2.3.2
     version: 
@@ -40,14 +40,16 @@ files:
 - lib/quarto/config.rb
 - lib/quarto/element_wrapper.rb
 - lib/quarto/generator.rb
+- lib/quarto/html_transformer.rb
 - lib/quarto/inheritable_attributes.rb
 - lib/quarto/init_project.rb
 - lib/quarto/rails_helper.rb
 - lib/quarto/rendering.rb
+- lib/quarto/transformation_helper.rb
+- lib/quarto/transformer.rb
 - lib/quarto/url_helper.rb
 - lib/quarto/xml_doc.rb
 - quarto.gemspec
-- test.rb
 has_rdoc: true
 homepage: http://github.com/jarrett/quarto
 post_install_message: 
@@ -80,6 +82,7 @@ test_files:
 - spec/generator_spec.rb
 - spec/init_project_spec.rb
 - spec/matchers/file_matchers.rb
+- spec/matchers/rexml_matchers.rb
 - spec/rendering_spec.rb
 - spec/sample_models.rb
 - spec/sample_project/generate.rb
@@ -90,4 +93,6 @@ test_files:
 - spec/sample_project/models/product.rb
 - spec/sample_project/urls.rb
 - spec/spec_helper.rb
+- spec/transformation_helper_spec.rb
+- spec/transformer_spec.rb
 - spec/url_helper_spec.rb

data/test.rb

@@ -1,20 +0,0 @@
-require 'erb'
-
-module Foo
-	def foo
-		6
-	end
-end
-
-template = ERB.new %q(
-The value of x is <%= x %>
-The method foo returns <%= foo %>
-)
-x = 42
-
-b = binding
-
-eval 'include Foo', b
-
-template.extend(Foo)
-puts template.result(b)