jarrett-quarto 0.3.0 → 0.3.1

data/Rakefile

@@ -0,0 +1,16 @@
+begin
+	require 'jeweler'
+	Jeweler::Tasks.new do |gemspec|
+		gemspec.name = 'quarto'
+		gemspec.summary = 'generates HTML or any other format from XML'
+		gemspec.email = 'jarrett@uchicago.edu'
+		gemspec.homepage = 'http://github.com/jarrett/quarto'
+		gemspec.description = '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.'
+		gemspec.authors = ['Jarrett Colby']
+		gemspec.files = FileList['[A-Z]*', '{bin,lib,test}/**/*']
+		gemspec.executables = 'quarto'
+	end
+rescue LoadError
+	puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.1

data/lib/quarto/children.rb

@@ -0,0 +1,152 @@
+module Quarto
+	# ElementWrapper subclasses can define parent and child elements, resulting
+	# in handy accessor methods. For example:
+	#
+	#   class Company < ElementWrapper
+	#     children :employees
+	#   end
+	#   
+	#   class Employee < ElementWrapper
+	#     parent :company
+	#     element_attr 'name'
+	#   end
+	#   
+	#   # in generate.rb:
+	#   company = Company.find :first
+	#   company.employees.each do |employee|
+	#     puts employee.name
+	#   end
+	
+	module ElementWrapperChildren
+		def self.included(base) # :nodoc:
+			base.extend(ClassMethods)
+			base.class_eval do
+				alias_method :method_missing_without_children, :method_missing
+				alias_method :method_missing, :method_missing_with_children
+				
+				alias_method :respond_to_without_children?, :respond_to?
+				alias_method :respond_to?, :respond_to_with_children?
+			end
+		end
+		
+		def method_missing_with_children(meth, *args) # :nodoc:
+			if self.class.has_children_named?(meth)
+				children_proxy(meth)
+			elsif self.class.has_parent_named?(meth)
+				wrapped_parent
+			else
+				method_missing_without_children(meth, *args)
+			end
+		end
+		
+		def respond_to_with_children?(meth, include_private = false) # :nodoc:
+			if self.class.has_children_named?(meth) or self.class.has_parent_named?(meth)
+				true
+			else
+				respond_to_without_children?(meth, include_private)
+			end
+		end
+		
+		protected
+		
+		def children_proxy(collection_el_name) # :nodoc:
+			@children_proxies ||= {}
+			@children_proxies[collection_el_name.to_s] ||= Children.new(self, collection_el_name.to_s.singularize)
+		end
+		
+		def wrapped_parent # :nodoc:
+			parent_el_name = self.class.read_inheritable_attribute(:parent)
+			parent_class_name = parent_el_name.classify
+			Kernel.const_get(parent_class_name).new(@element.parent.parent) # Go up two levels, since each child is expected to be inside a collection element
+		end
+		
+		module ClassMethods # :nodoc:
+			# :singleton-method:
+			# Define children. +el_name+ must be the singular form. In the XML, all children must be
+			# wrapped in a collection element whose name is the plural form.
+			#
+			#  Example:
+			#
+			#   <company>
+			#     <employees>
+			#       <employee>
+			#       </employee>
+			#     </employees>
+			#   </company>
+			#   
+			#   class Company < ElementWrapper
+			#     children :employees
+			#   end
+			def children(el_name)
+				write_inheritable_array(:children, [el_name.to_s])
+			end
+			
+			def has_children_named?(collection_el_name) # :nodoc:
+				return false if read_inheritable_attribute(:children).nil?
+				read_inheritable_attribute(:children).include?(collection_el_name.to_s)
+			end
+			
+			def has_parent_named?(parent_el_name) # :nodoc:
+				read_inheritable_attribute(:parent) == parent_el_name.to_s
+			end
+			
+			# :singleton-method:
+			# Defines the element's parent. Example:
+			#  Example:
+			#
+			#   <company>
+			#     <employees>
+			#       <employee>
+			#       </employee>
+			#     </employees>
+			#   </company>
+			#   
+			#   class Employee < ElementWrapper
+			#     parent :company
+			#   end
+			def parent(el_name)
+				write_inheritable_attribute(:parent, el_name.to_s)
+			end
+		end
+	end
+	
+	class Children
+		include Enumerable
+		
+		# Returns the REXML::Element for the children collection.
+		attr_reader :collection_element
+		
+		# Iterate over all children.
+		def each
+			to_a.each { |child| yield child }
+		end
+		
+		# Returns true if there are no children.
+		def empty?
+			to_a.empty?
+		end
+		
+		def initialize(wrapped_parent, el_name, options = {}) # :nodoc:
+			@wrapped_parent = wrapped_parent
+			@el_name = el_name.to_s
+			@collection_element = @wrapped_parent.element.elements[options[:collection_el_name] ||  @el_name.pluralize]
+			@wrapper_class = options[:wrapper_class] || Kernel.const_get(@el_name.classify)
+		end
+		
+		# Returns the number of children.
+		def length
+			to_a.length
+		end
+		
+		# Returns an array of all children. Each is an instance of ElementWrapper. If +xpath+ is provided, the results will be filtered. +xpath+ is relative to the parent element
+		def to_a(xpath = nil)
+			@all ||= @collection_element.elements.to_a(xpath || @el_name).collect do |el|
+				@wrapper_class.new(el)
+			end
+		end
+		
+		alias_method :size, :length
+	end
+end
+
+Quarto::ElementWrapper.send(:include, Quarto::ElementWrapperChildren)

data/lib/quarto/config.rb

@@ -0,0 +1,10 @@
+module Quarto
+	@config = {}
+	
+	def self.config(configs_to_merge = nil) # :nodoc:
+		if configs_to_merge.is_a?(Hash)
+			@config.merge!(configs_to_merge)
+		end
+		@config
+	end
+end

data/lib/quarto/element_wrapper.rb

@@ -0,0 +1,156 @@
+module Quarto
+	# Abstract base class for your models. Put your ElementWrapper subclasses inside the "models"
+	# directory within your project. All files in that directory will be automatically required.
+	#
+	# Each ElementWrapper subclass corresponds to exactly one XML element.
+	# You can specify the model's element name by calling element_name=, but
+	# generally, you just let ElementWrapper use the default, which is the subclass
+	# name in snake_case.
+	#
+	# Instance attributes corresponding to the XML attributes 
+	#
+	# For example, suppose you have an XML document like this:
+	#
+	#   <programmers>
+	#     <programmer skill="genius">
+	#       <name>Linus Torvalds</name>
+	#     <programmer>
+	#   </programmers>
+	#
+	# You could then subclass ElementWrapper like this:
+	#
+	#   class Programmer < ElementWrapper
+	#     element_name = 'programmer'
+	#     element_attrs 'name'
+	#   end
+	#
+	# You could then do something like this in your generate.rb file:
+	#
+	#   programmer = Programmer.find :first
+	#   puts programmer.name
+	#   puts programmer.skill
+	#
+	# Also see the documentation for Quarto::Children
+	
+	class ElementWrapper
+		include InheritableAttributes
+		
+		# Returns true if both instances come from the same node in the source XML document.
+		def ==(other_wrapped_element)
+			other_wrapped_element.is_a?(Quarto::ElementWrapper) and @element == other_wrapped_element.element
+		end
+		
+		# Returns the currently-loaded REXML::Document.
+		def self.xml_doc
+			Quarto.xml_doc
+		end
+		
+		# Returns the REXML::Element from which the instance was created.
+		attr_reader :element
+		
+		# Creates read-only attributes from the given strings. When a model is instantiated from an XML node,
+		# ElementWrapper will try to populate these attributes using the node's child elements.
+		#
+		# For example, if your "employee" element has a child element called "name," you can use:
+		#
+		#   element_attrs 'name'
+		#
+		# ...which will then expose a #name method for every instance of your class. Also see the usage example in the class description.
+		#
+		# Remember, XML attributes will automatically have corresponding ElementWrapper attributes. You only need to tell
+		# ElementWrapper which child elements to use.		
+		def self.element_attrs(*element_names)
+			write_inheritable_array :element_attrs, element_names.collect { |en| en.to_sym}
+		end
+		
+		# Returns the XML element name.
+		def self.element_name
+			@element_name
+		end
+		
+		# Overrides the XML element name. The default is the class name in snake_case.
+		def self.element_name=(el_name)
+			@element_name = el_name
+		end
+		
+		# Searches the XML document and returns instances of the class. The first parameter must be either :first, :last, or :all.
+		# If it's :first or :last, the method returns a single instance or nil. If it's :all, the method returns an array (which may be empty).
+		#
+		# Options:
+		#
+		# * <tt>:xpath</tt> - An XPath expression to limit the search. If this option is not given, the default XPath is "//element_name"
+		def self.find(quantifier, options = {})
+			raise ArgumentError, "Quantifier must be :all, :first, or :last, but got #{quantifier.inspect}" unless [:all, :first, :last].include?(quantifier)
+			raise ArgumentError, "Options must be a Hash, but got #{options.inspect}" unless options.is_a?(Hash)
+			if options.has_key?(:xpath)
+				xpath = options[:xpath]
+			else
+				xpath = "//#{@element_name}"
+				# TODO: add support for :root and :conditions (XPath predicates)
+			end
+			all = xml_doc.elements.to_a(xpath).collect do |el|
+				new(el)
+			end
+			case quantifier
+			when :all
+				all
+			when :first
+				all.first
+			when :last
+				all.last
+			end
+		end
+		
+		def self.inherited(subclass) # :nodoc:
+			subclass.element_name = subclass.to_s.underscore
+		end
+		
+		def initialize(el) # :nodoc:
+			unless el.is_a?(REXML::Element)
+				raise ArgumentError, "Quarto::ElementWrapper.new must be passed a REXML::Element, but got #{el.inspect}"
+			end
+			@element = el
+			@attributes = {}
+			@element.attributes.each do |a_name, value|
+				@attributes[a_name.to_sym] = typecast_text(value)
+			end
+			self.class.read_inheritable_attribute(:element_attrs).each do |el_name|
+				raise ArgumentError, "Expected <#{@element.name}> to contain <#{el_name}>" if @element.elements[el_name.to_s].nil?
+				@attributes[el_name.to_sym] = typecast_text(@element.elements[el_name.to_s].text)
+			end
+		end
+		
+		def method_missing(meth, *args, &block) # :nodoc:
+			if @attributes.has_key?(meth.to_sym)
+				@attributes[meth.to_sym]
+			elsif @element.respond_to?(meth)
+				@element.send(meth, *args, &block)
+			else	
+				super
+			end
+		end
+		
+		def respond_to?(meth, include_private = false) # :nodoc:
+			if @element.respond_to?(meth, include_private) or @attributes.has_key?(meth.to_sym)
+				true
+			else
+				super
+			end
+		end
+		
+		protected
+		
+		# When an ElementWrapper is instantiated from an XML node, all values start out as strings. This method typecasts those values.
+		def typecast_text(t)
+			if t.nil? or (t.is_a?(String) and t.empty?)
+				nil
+			elsif t =~ /^-?[0-9]+$/
+				t.to_i
+			elsif t =~ /^-?[0-9]*\.[0-9]+$/
+				t.to_f
+			else
+				t
+			end
+		end
+	end
+end

data/lib/quarto/generator.rb

@@ -0,0 +1,160 @@
+module Quarto
+	# Generates the project according to the directives in the block.
+	# A block must be supplied. The block will be evaluated within the context of
+	# a Quarto::Generator object.
+	#
+	# If the optional +project_path+ is given, the directives in the block willl
+	# be process for the project residing +project_path+. Otherwise, the current
+	# working directory will be used.
+	#
+	# This method is typically called from <tt>generate.rb</tt>. There's probably
+	# no reason for you to call it from any other context.
+	def self.generate(project_path = nil, &block)
+		unless block_given?
+			raise ArgumentError, 'Quarto.generate must be given a block'
+		end
+		# caller[0] returns the trace for the context that called generate. So, if generate.rb is invoked directly, Quarto will still work.
+		trace = caller()
+		unless trace.empty?
+			calling_file = trace[0].split(':')[-2]
+			if File.basename(calling_file) == 'generate.rb'
+				project_path = project_path || File.expand_path(File.dirname(calling_file))
+			end
+		end
+		unless project_path.is_a?(String) and !project_path.empty?
+			raise ArgumentError, 'project_path is required when Quarto.generate is called from any file other than generate.rb'
+		end
+		Dir.glob(project_path + '/models/*.rb').each do |model_file|
+			require model_file
+		end
+		generator = Quarto::Generator.new(project_path)
+		generator.generate(&block)
+		generator
+	end
+	
+	# Generates the project at the specified path using its generate.rb.
+	def self.generate_from_project_path(project_path)
+		raise ArgumentError, "Expected string, but got #{project_path.inspect}" unless project_path.is_a?(String) and !project_path.empty?
+		load(project_path + '/generate.rb')
+	end
+	
+	# This class responds to all the directives that are available for use within
+	# a generate.rb file.
+	class Generator
+		include 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>.
+		attr_accessor :default_layout
+		
+		# Generate the project according to the directives given in the block.
+		def generate(&block)
+			raise ArgumentError, 'generate must be called with a block' unless block_given?
+			if !File.exists? @output_path
+				Dir.mkdir @output_path
+			end
+			instance_eval(&block)
+		end
+		
+		def generate_file_path # :nodoc:
+			@project_path + '/generate.rb'
+		end
+		
+		# Options:
+		# * <tt>:console_output</tt> - Boolean. If true, the generator will print what it's currently doing.
+		# * <tt>:console</tt> - By default, console messages will be printed to stdout. You can override this
+		#   by passing in an object that responds to <tt>puts</tt>.
+		def initialize(project_path, options = {})
+			raise ArgumentError, "Expected string, but got #{project_path.inspect}" unless project_path.is_a?(String) and !project_path.empty?
+			raise ArgumentError, "Project path #{project_path} doesn't exist" unless File.exists?(project_path)
+			@project_path = project_path
+			@output_path = project_path + '/output'
+			@options = {:console_output => true, :console => Kernel}.merge(options)
+			@console = @options[:console]
+		end
+		
+		attr_reader :output_path # :nodoc:
+		
+		protected
+		
+		# Set a configuration for Quarto to use during generation, e.g. <tt>:site_root</tt>
+		def config(key, value)
+			Quarto.config[key] = value
+		end
+		
+		# Render the given +template+, and save the output in +filename+ under +directory+.
+		# +locals+ is a hash where they keys are the names of local variables in the template
+		#
+		# Options:
+		# * <tt>:layout</tt> - Render inside the specified layout. Must be the name of
+		#   a file in the layouts directory, e.g. <tt>my_layout.html.erb</tt>. If not given,
+		#   the <tt>default_layout</tt> will be used.
+		#
+		# Example:
+		#   employees.each do |employee|
+		#     render 'employee.html.erb', 'employees', urlize(employee.name) + '.html', :employee => employee
+		#   end
+		#
+		# That example will create a number of files with names like "John-Smith.html"
+		# in the "employees" directory
+		def render(template, directory, filename, locals, options = {})
+			if @options[:console_output]
+				if directory.is_a?(String) and !directory.empty?
+					@console.puts "Writing from template #{template} to output/#{directory}/#{filename}"
+				else
+					@console.puts "Writing from template #{template} to output/#{filename}"
+				end
+			end
+			
+			if directory.nil? or directory.empty?
+				path = "#{@output_path}/#{filename}"
+			else
+				subdir = "#{@output_path}/#{directory}"
+				if !File.exists? subdir
+					Dir.mkdir subdir
+				end
+				path = "#{subdir}/#{filename}"
+			end
+			
+			File.open(path, 'w') do |file|
+				file.print render_to_s(template, locals, options)
+			end
+		end
+		
+		# Renders +template+ to a string. Sets local variables within the template to the values given
+		# in +locals+.
+		def render_to_s(template, locals, options = {})
+			page_template_path = "#{@project_path}/pages/#{template}"
+			page_template = ERB.new(File.read(page_template_path))
+			page_content = Rendering.render(page_template, locals)
+			
+			if options.has_key?(:layout)
+				layout = options[:layout]
+			elsif (@default_layout and File.exists?("#{@project_path}/layouts/#{@default_layout}"))
+				layout = @default_layout
+			elsif @default_layout = Dir.glob("#{@project_path}/layouts/default.*.erb")[0]
+				@default_layout = File.basename(@default_layout)
+				layout = @default_layout
+			else
+				layout = nil
+			end
+			
+			if layout
+				layout_template_path = "#{@project_path}/layouts/#{layout}"
+				layout_template = ERB.new(File.read(layout_template_path))
+				Rendering.render(layout_template, locals) do
+					page_content
+				end
+			else
+				page_content
+			end
+		end
+		
+		# Specifies which XML file to use. Must be the name of a file in the xml directory, e.g. <tt>companies.xml</tt>.
+		# This method absolutely must be called within <tt>generate.rb</tt>. Otherwise, Quarto won't know what XML
+		# to use as its source.
+		def use_xml(xml_filename)
+			Quarto.xml_source = File.open("#{@project_path}/xml/#{xml_filename}")
+		end
+	end
+end

data/lib/quarto/inheritable_attributes.rb

@@ -0,0 +1,31 @@
+# Thanks to ActiveSupport for this stuff
+
+module Quarto
+	module InheritableAttributes # :nodoc: all
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+		module ClassMethods
+			def read_inheritable_attribute(key)
+				@inheritable_attributes ||= {}
+				@inheritable_attributes[key]
+			end
+			
+			def write_inheritable_array(key, elements)
+				write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+				write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+			end
+			
+			def write_inheritable_attribute(key, value)
+				@inheritable_attributes ||= {}
+				@inheritable_attributes[key] = value
+			end
+			
+			def write_inheritable_hash(key, hash)
+				write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+				write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+			end
+		end
+	end
+end

data/lib/quarto/init_project.rb

@@ -0,0 +1,38 @@
+module Quarto
+	PROJECT_SUBFOLDERS = [
+		'layouts',
+		'models',
+		'output',
+		'pages',
+		'xml'
+	]
+
+	STARTER_GENERATE_FILE = %q(
+Quarto.generate do
+	# Your code here
+	# e.g.:
+	# render 'companies.html.erb', '', 'companies.html', :companies => Company.find(:all)
+end
+)
+	# Initialize a new Quarto project at the specified path. Creates a generate.rb file and the necessary subfolders.
+	def self.init_project(project_path)
+		raise ArgumentError, "Expected string, but got #{project_path.inspect}" unless project_path.is_a?(String) and !project_path.empty?
+		project_path = File.expand_path(project_path)
+		unless File.exists?(project_path)
+			Dir.mkdir project_path
+		end
+		PROJECT_SUBFOLDERS.each do |subfolder|
+			subfolder = project_path + '/' + subfolder
+			unless File.exists?(subfolder)
+				Dir.mkdir subfolder
+			end
+		end
+		generate_file = project_path + '/generate.rb'
+		unless File.exists?(generate_file)
+			File.open(generate_file, 'w') do |file|
+				file.print(STARTER_GENERATE_FILE)
+			end
+		end
+		true
+	end
+end

data/lib/quarto/rendering.rb

@@ -0,0 +1,22 @@
+module Quarto
+	class Rendering # :nodoc: all
+		include UrlHelper
+		
+		def initialize(__erb_template, __locals)
+			__b = binding
+			__locals.each_key do |var_name|
+				# In the context of this method (rather than of this block),
+				# define the local variables
+				eval "#{var_name} = __locals[:#{var_name}]", __b
+			end
+			
+			@result = __erb_template.result(__b)
+		end
+		
+		def self.render(erb_template, locals, &block)
+			new(erb_template, locals, &block).result
+		end
+		
+		attr_reader :result
+	end
+end

data/lib/quarto/url_helper.rb

@@ -0,0 +1,17 @@
+require 'cgi'
+
+module Quarto
+	module UrlHelper
+		# Generates an absolute URL, using the <tt>:site_root</tt> config value. (To change <tt>:site_root</tt>,
+		# put something like this in <tt>generate.rb</tt>:
+		#   config(:site_root, 'http://your_domain.com/whatever')
+		def abs_url(str)
+			"#{Quarto.config[:site_root]}#{str}"
+		end
+		
+		# Replaces spaces with dashes and deletes special characters.
+		def urlize(str)
+			str.to_s.gsub(/[^ a-zA-Z0-9_-]/, '').tr(' ', '-')
+		end
+	end
+end

data/lib/quarto/xml_doc.rb

@@ -0,0 +1,10 @@
+module Quarto
+	def self.xml_source=(source) # :nodoc:
+		raise ArgumentError, "Expected File but got #{source.inspect}" unless source.is_a?(File)
+		@xml_doc = REXML::Document.new(source)
+	end
+	
+	def self.xml_doc # :nodoc:
+		@xml_doc
+	end
+end

data/lib/quarto.rb

@@ -0,0 +1,16 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'rexml/document'
+require 'erb'
+require 'active_support/inflector'
+
+require 'quarto/config'
+require 'quarto/xml_doc'
+require 'quarto/inheritable_attributes'
+require 'quarto/url_helper'
+require 'quarto/element_wrapper'
+require 'quarto/children'
+require 'quarto/rendering'
+require 'quarto/generator'
+require 'quarto/init_project'

data/quarto.gemspec

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{quarto}
+  s.version = "0.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jarrett Colby"]
+  s.date = %q{2009-06-05}
+  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}
+  s.executables = ["quarto"]
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+     "Rakefile",
+     "VERSION",
+     "bin/quarto",
+     "lib/quarto.rb",
+     "lib/quarto/children.rb",
+     "lib/quarto/config.rb",
+     "lib/quarto/element_wrapper.rb",
+     "lib/quarto/generator.rb",
+     "lib/quarto/inheritable_attributes.rb",
+     "lib/quarto/init_project.rb",
+     "lib/quarto/rendering.rb",
+     "lib/quarto/url_helper.rb",
+     "lib/quarto/xml_doc.rb",
+     "quarto.gemspec"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/jarrett/quarto}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{generates HTML or any other format from XML}
+  s.test_files = [
+    "spec/children_spec.rb",
+     "spec/element_wrapper_spec.rb",
+     "spec/generator_spec.rb",
+     "spec/init_project_spec.rb",
+     "spec/matchers/file_matchers.rb",
+     "spec/sample_project/generate.rb",
+     "spec/sample_project/models/company.rb",
+     "spec/sample_project/models/employee.rb",
+     "spec/spec_helper.rb",
+     "spec/url_helper_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jarrett-quarto
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Jarrett Colby
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-04 00:00:00 -07:00
+date: 2009-06-05 00:00:00 -07:00
 default_executable: quarto
 dependencies: []
 
@@ -23,6 +23,20 @@ extra_rdoc_files:
 - README
 files: 
 - README
+- Rakefile
+- VERSION
+- bin/quarto
+- lib/quarto.rb
+- lib/quarto/children.rb
+- lib/quarto/config.rb
+- lib/quarto/element_wrapper.rb
+- lib/quarto/generator.rb
+- lib/quarto/inheritable_attributes.rb
+- lib/quarto/init_project.rb
+- lib/quarto/rendering.rb
+- lib/quarto/url_helper.rb
+- lib/quarto/xml_doc.rb
+- quarto.gemspec
 has_rdoc: true
 homepage: http://github.com/jarrett/quarto
 post_install_message: