reno 0.1.0

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2010, Zoxc
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Zoxc nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/reno.rb

@@ -0,0 +1,20 @@
+module Reno
+	require 'rexml/document'
+	
+	ROOT = File.dirname(File.expand_path(__FILE__)) unless defined?(Reno::ROOT)
+ 
+	unless $LOAD_PATH.any? { |lp| File.expand_path(lp) == ROOT }
+		$LOAD_PATH.unshift(ROOT)
+	end
+
+	require 'reno/lock'
+	require 'reno/configuration'
+	require 'reno/builder'
+	require 'reno/cache'
+	require 'reno/platforms'
+	require 'reno/sourcefile'
+	require 'reno/options'
+	require 'reno/languages'
+	require 'reno/toolchains'
+	require 'reno/package'
+end

data/reno/builder.rb

@@ -0,0 +1,136 @@
+require 'pathname'
+require 'fileutils'
+
+module Reno
+	class BuilderError < StandardError
+	end
+	
+	class Builder
+		attr_reader :sources, :cache, :sqlcache, :base, :output, :objects, :package, :conf
+		attr :conf, true
+
+		def self.readydirs(path)
+			FileUtils.makedirs(File.dirname(path))
+		end
+		
+		def self.cleanpath(base, path)
+			Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(base)).to_s
+		end
+		
+		def self.execute(command, *args)
+			#puts [command, *args].join(' ')
+			IO.popen([command, *args]) do |f|
+				f.readlines
+			end
+			raise "#{command} failed with error code #{$?.exitstatus}" if $?.exitstatus != 0
+		end
+		
+		def self.capture(command, *args)
+			#puts [command, *args].join(' ')
+			result = nil
+			IO.popen([command, *args]) do |f|
+				result = f.readlines.join('')
+			end
+			raise "#{command} failed with error code #{$?.exitstatus}" if $?.exitstatus != 0
+			result
+		end
+	 
+		def self.clean(filename)
+			if File.exists?(filename)
+				File.delete(filename)
+				begin
+					dir = File.dirname(filename)
+					while File.exists?(dir)
+						Dir.rmdir(dir)
+						dir = File.dirname(dir)
+					end
+				rescue SystemCallError
+				end
+			end
+		end
+		
+		def puts(*args)
+			@puts_lock.synchronize do
+				Kernel.puts *args
+			end
+		end
+		
+		def output(file)
+			result = File.expand_path(file, @bulid_base)
+			Builder.readydirs(result)
+			result
+		end
+		
+		def initialize(package)
+			@package = package
+			@changed = Lock.new
+			@base = @package.base
+			@bulid_base = File.expand_path(@package.output, @base)
+			@objects = Lock.new([])
+			@files = Lock.new([])
+			@puts_lock = Mutex.new
+			@cache =  Lock.new({})
+		end
+		
+		def run(threads = 8)
+			# Creates an unique list of the files
+			@files.value = Dir[*@conf.get(:patterns)].map { |file| Builder.cleanpath(@base, file) }.uniq
+			@sqlcache = Cache.new(self)
+			
+			# Start worker threads	
+			workers = []
+			threads.times do
+				workers << Thread.new do
+					work
+				end
+			end
+			
+			# Wait for all the workers
+			workers.each { |worker| worker.join }
+			
+			# Normalize locks
+			@objects = @objects.value
+			
+			# Link the package if it changed or the output doesn't exist
+			
+			output_name = output(package.output_name)
+			
+			if @changed.value || !File.exists?(output_name)
+				puts "Linking #{@package.name}..."
+				
+				# Find a toochain to link this package
+				linker = @package.default[:linker]
+				linker = Toolchains::Hash.values.first unless linker
+				raise BuilderError, "Unable to find a linker to use." unless linker
+				
+				linker.link(self, output(package.output_name))
+			else
+				puts "Nothing to do with #{@package.name}."
+			end
+		end
+		
+		def get_file
+			@files.lock do |files|
+				files.pop
+			end
+		end
+		
+		def output_file(result)
+			@objects.lock do |output|
+				output << result
+			end
+		end
+		
+		def work
+			while filename = get_file
+				file = SourceFile.locate(self, filename)
+				rebuild = file.rebuild?
+				if rebuild
+					@changed.value = true
+					file.build
+				end
+				output_file file
+			end
+		end
+	end
+end

data/reno/cache.rb

@@ -0,0 +1,57 @@
+require 'pathname'
+require 'sequel'
+
+module Reno
+	class Cache
+		attr_reader :base, :db
+		
+		class FileModel
+			def initialize(db, name, &block)
+				@db = db
+				@row = @db[:name => name]
+				unless @row
+					@row = block.call
+					@row[:id] = @db.insert(@row)
+				end
+			end
+			
+			def [](name)
+				@row[name]
+			end
+			
+			def []=(name, value)
+				@row[name] = value
+				@db.filter(:id => @row[:id]).update(name => value)
+			end
+		end
+		
+		def setup_table(name, &block)
+			@db.create_table(name, &block) unless @db.table_exists?(name)
+		end
+		
+		def initialize(builder)
+			@db = Sequel.sqlite(:database => builder.output('cache.db'))
+			
+			setup_table :files do
+				primary_key :id, :type => Integer
+				String :name
+				String :md5
+				String :output
+				FalseClass :dependencies
+			end
+			
+			setup_table :dependencies do
+				Integer :file
+				Integer :dependency
+			end
+			
+			Languages.constants.each do |language|
+				language = Languages.const_get(language)
+				
+				next if language.superclass != Languages::Language
+				
+				language.setup_schema(self)
+			end
+		end
+	end
+end

data/reno/configuration.rb

@@ -0,0 +1,50 @@
+module Reno
+	class ConfigurationError < StandardError
+	end
+	
+	class ConfigurationNode
+		attr_reader :langs, :builder, :parent, :hash, :patterns
+		
+		def initialize(package, builder, parent, patterns)
+			@package = package
+			@builder = builder
+			@parent = parent
+			@patterns = patterns.to_a
+			@children = []
+			@hash = {}
+		end
+		
+		def add(name, values)
+			@hash[name] = [] unless @hash.has_key?(name)
+			@hash[name].concat(values)
+		end
+		
+		def get(name, file = nil, base = nil)
+			if file && !@patterns.empty?
+				Dir.chdir(base) do
+					return nil unless @patterns.any? { |pattern| File.fnmatch?(pattern, file) }
+				end
+			end
+			
+			child_values = []
+			
+			@children.each do |child|
+				child_values.concat(child.get(name, file).reject { |value| !value })
+			end
+			
+			if Array === @hash[name]
+				@hash[name] + child_values
+			else
+				child_values
+			end
+		end
+		
+		def derive(patterns)
+			patterns = patterns.to_a
+			child = ConfigurationNode.new(@package, @builder, self, patterns)
+			child.add(:patterns, patterns)
+			@children << child
+			child
+		end
+	end
+end

data/reno/languages.rb

@@ -0,0 +1,61 @@
+module Reno
+	module Languages
+		class LanguageError < StandardError
+		end
+		
+		def self.locate(name)
+			Languages.constants.map { |lang| Languages.const_get(lang) }.each do |language|
+
+				next if language.superclass != Language
+				
+				if language.name == name
+					return language
+				end
+			end
+			
+			raise "Unable to find the language '#{name}'."
+		end
+	
+		class Language
+			attr_reader :option
+			
+			def inspect
+				"#<Language:#{self.class.name}>"
+			end
+			
+			def initialize(option, block)
+				@option = option
+				instance_eval(&block) if block
+			end
+			
+			def get_dependencies(file)
+				[]
+			end
+			
+			def read(name)
+				instance_variable_get "@#{name}"
+			end
+			
+			class << self
+				attr :name, true
+				
+				def table_name(name)
+					"lang_#{self.name}_#{name}".downcase.to_sym
+				end
+				
+				def setup_table(cache, name, &block)
+					cache.setup_table(table_name(name), &block)
+				end
+				
+				def setup_schema(cache)
+				end
+				
+				def merge(nodes)
+					result = new(nil, nil)
+					nodes.each { |node| result.merge(node) }
+					result
+				end
+			end
+		end
+	end
+end

data/reno/languages/c.rb

@@ -0,0 +1,156 @@
+module Reno
+	module Languages
+		class C < Language
+			self.name = 'C'
+			
+			def initialize(*args)
+				@defines = {}
+				@headers = []
+				@std = nil
+				@strict = nil
+				super
+			end
+			
+			def compare(file)
+				defines = file.db[self.class.table_name(:defines)]
+				attribs = file.db[self.class.table_name(:attribs)]
+				
+				hash = {}
+				
+				defines.filter(:file => file.row[:id]).all do |row|
+					hash[row[:define]] = row[:value]
+				end
+				
+				attribs = attribs.filter(:file => file.row[:id]).first
+				attribs = {:std => nil, :strict => false} unless attribs
+				
+				hash == @defines and attribs[:std] == @std.to_s and attribs[:strict] == @strict
+			end
+			
+			def print(*values)
+				puts values.inspect
+			end
+			
+			def store(file)
+				defines = file.db[self.class.table_name(:defines)]
+				attribs = file.db[self.class.table_name(:attribs)]
+				
+				# Delete existing rows				
+				defines.filter(:file => file.row[:id]).delete
+				attribs.filter(:file => file.row[:id]).delete
+				
+				# Add the current ones
+				@defines.each_pair do |key, value|
+					defines.insert(:file => file.row[:id], :define => key, :value => value)
+				end
+				
+				attribs.insert(:file => file.row[:id], :strict => @strict, :std => @std.to_s)
+			end
+			
+			def self.setup_schema(cache)
+				setup_table(cache, :defines) do
+					Integer :file
+					String :define
+					String :value
+				end
+				
+				setup_table(cache, :attribs) do
+					Integer :file
+					FalseClass :strict
+					String :std
+				end
+			end
+			
+			def merge(other)
+				@defines.merge!(other.read(:defines))
+				
+				other_value = other.read(:std)
+				@std = other_value if other_value
+				
+				other_value = other.read(:strict)
+				@strict = other_value if other_value != nil
+			end
+			
+			def define(name, value = nil)
+				@defines[name] = value
+			end
+			
+			def strict(value = true)
+				@strict = value
+			end
+			
+			def std(value)
+				@std = value
+			end
+			
+			def headers(*dirs)
+				@headers.concat(dirs)
+			end
+			
+			def self.extensions
+				['.c', '.h']
+			end
+			
+			# The get_dependencies method is under the GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 license.
+			# It's from rant-0.5.8\lib\rant\c\include.rb
+			
+			# include.rb - Support for C - parsing #include statements.
+			#
+			# Copyright (C) 2005 Stefan Lang <langstefan@gmx.at>
+
+			
+			# Searches for all `#include' statements in the C/C++ source
+			# from the string +src+.
+			#
+			# Returns two arguments:
+			# 1. A list of all standard library includes (e.g. #include <stdio.h>).
+			# 2. A list of all local includes (e.g. #include "stdio.h").
+			
+			def self.get_dependencies(file)
+				src = file.content
+
+				includes = []
+				in_block_comment = false
+				prev_line = nil
+				
+				src.each_line do |line|
+					line.chomp!
+					
+					if block_start_i = line.index("/*")
+						c_start_i = line.index("//")
+						if !c_start_i || block_start_i < c_start_i
+							if block_end_i = line.index("*/")
+								if block_end_i > block_start_i
+									line[block_start_i..block_end_i+1] = ""
+								end
+							end
+						end
+					end
+					
+					if prev_line
+						line = prev_line << line
+						prev_line = nil
+					end
+					
+					if line =~ /\\$/
+						prev_line = line.chomp[0...line.length-1]
+					end
+					
+					if in_block_comment
+						in_block_comment = false if line =~ %r|\*/|
+						next
+					end
+					
+					case line
+						when /\s*#\s*include\s+"([^"]+)"/
+							includes << $1
+						when %r|(?!//)[^/]*/\*|
+							in_block_comment = true
+					end
+				end
+				
+				includes
+			end
+		end
+	end
+end

data/reno/lock.rb

@@ -0,0 +1,33 @@
+module Reno
+	class Lock
+		def initialize(value = nil)
+			@value = value
+			@mutex = Mutex.new
+		end
+		
+		def lock
+			@mutex.synchronize do
+				yield @value
+			end
+		end
+		
+		def value
+			if block_given?
+				@mutex.synchronize do
+					return @value if @value
+					@value = yield
+				end
+			else
+				@mutex.synchronize do
+					@value
+				end
+			end
+		end
+		
+		def value=(value)
+			@mutex.synchronize do
+				@value = value
+			end
+		end
+	end
+end

data/reno/options.rb

@@ -0,0 +1,89 @@
+module Reno
+	class Option
+		attr_reader :package, :parent, :name, :desc, :children
+		
+		def initialize(package, parent, name = nil, desc = nil, default = nil, block)
+			@package = package
+			@parent = parent
+			@name = name
+			@desc = desc
+			@default = default
+			@children = []
+			@langs = {}
+			instance_eval(&block) if block
+		end
+		
+		def apply_config(conf, data)
+			conf.add(:langs, [@langs])
+			@children.each do |child|
+				child_data = data.elements.find { |element| element.attribute('name').value == child.name.to_s && element.name == child.xml_node } if data
+				child.apply_config(conf, child_data)
+			end
+		end
+		
+		def xml_node
+			"group"
+		end
+		
+		def o(name, desc = nil, default = false, &block)
+			@children << BooleanOption.new(@package, self, name, desc, default, block)
+		end
+		
+		def group(name, desc = nil, &block)
+			@children << Option.new(@package, self, name, desc, block)
+		end
+		
+		def source(*args, &block)
+			@children << SourceOption.new(@package, self, block, args)
+		end
+		
+		alias :sources :source
+		
+		def default(hash)
+			@package.default.merge!(hash)
+		end
+		
+		def lang(name = nil, &block)
+			lang = name || @package.default[:lang]
+			
+			raise "Unable to find the default language." unless lang
+			
+			lang = lang.to_s
+			
+			return @langs[lang] if @langs[lang]
+			
+			obj = Languages.locate(lang).new(self, block)
+			@langs[lang] = obj
+			obj
+		end
+	end
+	
+	class BooleanOption < Option
+		def apply_config(conf, data)
+			if (data && data.attribute('value')) ? data.attribute('value').value == "true" : @default
+				super
+			end
+		end
+		
+		def xml_node
+			"option"
+		end
+		
+	end
+	
+	class SourceOption < Option
+		def initialize(*args, sources)
+			@sources = sources
+			super *args
+		end
+		
+		def apply_config(conf, data)
+			conf = conf.derive(@sources)
+			super
+		end
+		
+		def xml_node
+			"file"
+		end
+	end
+end

data/reno/package.rb

@@ -0,0 +1,82 @@
+module Reno
+	class PackageError < StandardError
+	end
+	
+	Packages = {}
+	
+	class PackageOption < Option
+		def name(name)
+			@package.name = name
+		end
+		
+		def desc(desc)
+			@package.desc = desc
+		end
+		
+		def version(version)
+			@package.version = version
+		end
+	end
+
+	class Package
+		attr_reader :default, :name, :base, :output
+		attr :desc, true
+		attr :version, true
+
+		def initialize(&block)
+			@default = {}
+			@output = 'build'
+			@base = Dir.getwd
+			# This should be the last thing to be set up. The object might depend on the other variables.
+			@option = PackageOption.new(self, nil, block)
+
+			self
+		end
+		
+		def output_name
+			raise "You can't link packages!"
+		end
+		
+		def name=(name)
+			raise "You have already assigned this package a name" if @name
+			
+			@name = name.to_s
+
+			raise PackageError, "The package #{@name} already exist." if Packages[@name]
+			Packages[@name] = self
+		end
+		
+		def builder(data = nil)
+			builder = Builder.new(self)
+			conf = ConfigurationNode.new(@option.package, builder, nil, [])
+			@option.apply_config(conf, data)
+			builder.conf = conf
+			builder
+		end
+
+		def load_config(data)
+			conf = PackageConf.new(self)
+			Options.new(conf, data, @options)
+		end
+	end
+
+	class Library < Package
+		def output_name
+			if Rake::Win32.windows?
+				@name + '.dll'
+			else
+				@name + '.so'
+			end
+		end
+	end
+	
+	class Application < Package
+		def output_name
+			if Platforms.current == Platforms::Windows
+				@name + '.exe'
+			else
+				@name
+			end
+		end
+	end
+end

data/reno/platforms.rb

@@ -0,0 +1,17 @@
+module Reno
+	module Platforms
+		class Windows
+		end
+		
+		class Unix
+		end
+		
+		def self.current
+			if RUBY_PLATFORM =~ /(win|w)32$/
+				Windows
+			else
+				Unix
+			end
+		end
+	end
+end

data/reno/sourcefile.rb

@@ -0,0 +1,139 @@
+require 'digest/md5'
+
+module Reno
+	class SourceFileError < StandardError
+	end
+	
+	class SourceFile
+		attr_reader :path, :name, :row, :db, :builder
+		
+		def self.locate(builder, filename)
+			builder.cache.lock do |cache|
+				return cache[filename] || new(builder, filename, cache)
+			end
+		end
+		
+		def initialize(builder, filename, cache)
+			@builder = builder
+			@name = filename
+			@path = File.expand_path(@name, @builder.base)
+			@changed = Lock.new
+			@language = Lock.new
+			@lang_conf = Lock.new
+			@compiler = Lock.new
+			@output = Lock.new
+			@content = Lock.new
+			@digest = Lock.new
+			cache[filename] = self
+			@db = @builder.sqlcache.db
+			@row = Cache::FileModel.new(@db[:files], @name) do
+				{:name => @name, :md5 => digest, :dependencies => false, :output => nil}
+			end
+		end
+		
+		def find_language
+			file_ext = File.extname(@name).downcase
+			
+			Languages.constants.map { |name| Languages.const_get(name) }.each do |language|
+				next if language.superclass != Languages::Language
+				
+				if language.extensions.any? { |ext| ext == file_ext }
+					return language
+				end
+			end
+			
+			raise SourceFileError, "Unable to find a language for the file '#{@name}'."
+		end
+		
+		def digest
+			@digest.value {	Digest::MD5.hexdigest(content) }
+		end
+		
+		def content
+			@content.value { File.open(@path, 'rb') { |f| f.read } }
+		end
+		
+		def output
+			@output.value { @builder.output(@name + '.o') }
+		end
+		
+		def language
+			@language.value { find_language }
+		end
+		
+		def compiler
+			@compiler.value { Toolchains.locate(language) }
+		end
+		
+		def lang_conf
+			@lang_conf.value do
+				langs = @builder.conf.get(:langs, nil).map { |langs| langs[language.name] }.reject { |lang| !lang }
+				language.merge(langs)
+			end
+		end
+		
+		def get_dependencies
+			@builder.puts "Getting dependencies for #{@name}..."
+			@db[:dependencies].filter(:file => @row[:id]).delete
+			
+			dependencies = compiler.get_dependencies(self)
+			dependencies.each do |path|
+				file = SourceFile.locate(@builder, Builder.cleanpath(@builder.base, path))
+				@db[:dependencies].insert(:file => @row[:id], :dependency => file.row[:id])
+			end
+			
+			@row[:dependencies] = true
+		end
+		
+		def dependencies_changed?
+			get_dependencies unless @row[:dependencies]
+			
+			dependencies = @db[:dependencies].filter(:file => @row[:id]).all
+			
+			dependencies.any? do |dependency|
+				SourceFile.locate(@builder, @db[:files][:id => dependency[:dependency]][:name]).changed?
+			end
+		end
+		
+		def changed?
+			@changed.value do |changed|
+				# Check if the file has changed and reset dependencies and output if needed
+				
+				if !File.exists?(@path)
+					@row[:dependencies] = false
+					changed = true
+				elsif @row[:md5] != digest then
+					@row[:dependencies] = false
+					@row[:md5] = digest
+					changed = true
+				else
+					changed = dependencies_changed? ? true : false
+				end
+
+				@row[:output] = nil if changed
+				
+				changed
+			end
+		end
+		
+		def rebuild?
+			return true unless @row[:output] and File.exists?(File.expand_path(@row[:output], @builder.base)) and lang_conf.compare(self)
+			
+			changed?
+		end
+		
+		def build
+			@builder.puts "Compiling #{@name}..."
+			compiler.compile(self)
+			
+			output = @output.value
+			
+			if File.exists? output
+				@row[:output] = output
+				lang_conf.store(self)
+			else
+				raise SourceFileError, "Can't find output '#{output}' from #{name}."
+			end
+		end
+	end
+end

data/reno/toolchains.rb

@@ -0,0 +1,39 @@
+module Reno
+	module Toolchains
+		class ToolchainError < StandardError
+		end
+		
+		Hash = {}
+		Compilers = {}
+		
+		def self.register(toolchain, language)
+			array = Compilers[language]
+			array = Compilers[language] = [] unless array
+			array << toolchain
+		end
+		
+		def self.locate(language)
+			array = Compilers[language.name]
+
+			raise "Unable to find a compiler for the language '#{language.name}'." unless array
+			
+			array.first
+		end
+	
+		class Toolchain
+			attr_reader :option
+			
+			def self.get_dependencies(file)
+				file.language.get_dependencies(file)
+			end
+			
+			def self.register(name, *languages)
+				Hash[name] = self
+				
+				languages.each do |language|
+					Toolchains.register(self, language)
+				end
+			end
+		end
+	end
+end

data/reno/toolchains/gnu.rb

@@ -0,0 +1,53 @@
+module Reno
+	module Toolchains
+		class Gnu < Toolchain
+			register :gnu, 'C'
+			
+			class << self	
+				def command(file = nil)
+					ENV['CC'] || 'gcc'
+				end
+				
+				def language(file)
+					case file.lang_conf
+						when Languages::C
+							'c'
+						else
+							raise ToolchainError, "GCC doesn't support the language #{file.language.name}."
+					end
+				end
+				
+				def compile(file)
+					Builder.execute(command(file), '-pipe', *defines(file), *std(file), '-x', language(file), '-c', file.path, '-o', file.output)
+				end
+				
+				def std(file)
+					case file.lang_conf.read(:std)
+						when nil
+							return []
+						when :c89
+							result = '89'
+						when :c99
+							result = '99'
+						else
+							raise ToolchainError, "Unable to find language mode #{file.lang_conf.read(:std)}."
+					end
+					
+					["-std=#{file.lang_conf.read(:strict) ? "c" : "gnu"}#{result}"]
+				end
+				
+				def defines(file)
+					defines = []
+					file.lang_conf.read(:defines).each_pair do |key, value|
+						defines << '-D' << (value ? "#{key}=#{value}" : key.to_s)
+					end
+					defines
+				end
+				
+				def link(builder, output)
+					Builder.execute(command, '-pipe', *builder.objects.map { |object| object.output }, '-o', output)
+				end
+			end
+		end
+	end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: reno
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Zoxc
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-04 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- reno.rb
+- reno/builder.rb
+- reno/cache.rb
+- reno/configuration.rb
+- reno/languages/c.rb
+- reno/languages.rb
+- reno/lock.rb
+- reno/options.rb
+- reno/package.rb
+- reno/platforms.rb
+- reno/sourcefile.rb
+- reno/toolchains/gnu.rb
+- reno/toolchains.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.9.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: Reno is a compiling framework in Ruby.
+test_files: []
+