clj 0.0.6.1 → 0.0.7

data/ext/clj/extconf.rb

@@ -5,7 +5,7 @@ unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
 end
 
 if CONFIG['CC'] =~ /gcc/
-	$CFLAGS << ' -Wall' << ' -std=c99'
+	$CFLAGS << ' -Wall'
 
 	if $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
 		$CFLAGS << ' -O0 -ggdb'

data/ext/clj/parser.c

@@ -32,7 +32,8 @@ typedef enum {
 	NODE_VECTOR,
 	NODE_INSTANT,
 	NODE_SET,
-	NODE_REGEXP
+	NODE_REGEXP,
+	NODE_SYMBOL
 } NodeType;
 
 #define CALL(what) (what(self, string, position))
@@ -50,14 +51,17 @@ typedef enum {
 #define IS_EQUAL_UP_TO(str, n) (strncmp(CURRENT_PTR, str, (n)) == 0)
 #define IS_EQUAL(str) IS_EQUAL_UP_TO(str, strlen(str))
 #define IS_IGNORED(ch) (isspace(ch) || ch == ',')
-#define IS_BOTH(ch) (ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == '\n' || ch == '\r' || ch == '\t')
-#define IS_KEYWORD(ch) (ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == '\'' || ch == '^' || ch == '@' || ch == '`' || ch == '~' || ch == '\\' || ch == ';' || ch == '\n' || ch == '\r' || ch == '\t')
+#define IS_SYMBOL(ch) (isdigit(ch) || isalpha(ch) || ch == '+' || ch == '!' || ch == '-' || ch == '_' || ch == '?' || ch == '.' || ch == ':' || ch == '/')
+#define IS_BOTH_SEPARATOR(ch) (ch == '\0' || ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == '\n' || ch == '\r' || ch == '\t')
+#define IS_KEYWORD_SEPARATOR(ch) (ch == '\0' || ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == '\'' || ch == '^' || ch == '@' || ch == '`' || ch == '~' || ch == '\\' || ch == ';' || ch == '\n' || ch == '\r' || ch == '\t')
 
-static VALUE read_next (VALUE self, char* string, size_t* position);
+static VALUE read_next (STATE);
 
 static inline bool is_not_eof_up_to (char* string, size_t* position, size_t n)
 {
-	for (size_t i = 0; i < n; i++) {
+	size_t i;
+
+	for (i = 0; i < n; i++) {
 		if (IS_EOF_AFTER(i)) {
 			return false;
 		}
@@ -103,7 +107,7 @@ static NodeType next_type (STATE)
 		}
 	}
 
-	rb_raise(rb_eSyntaxError, "unknown type");
+	return NODE_SYMBOL;
 }
 
 static VALUE read_metadata (STATE)
@@ -111,6 +115,7 @@ static VALUE read_metadata (STATE)
 	VALUE  result;
 	VALUE* metadatas = NULL;
 	size_t length    = 0;
+	size_t i;
 
 	while (CURRENT == '^') {
 		metadatas = realloc(metadatas, ++length * sizeof(VALUE));
@@ -129,7 +134,7 @@ static VALUE read_metadata (STATE)
 	}
 
 	// FIXME: this could lead to a memleak if #metadata= raises
-	for (size_t i = 0; i < length; i++) {
+	for (i = 0; i < length; i++) {
 		rb_funcall(result, rb_intern("metadata="), 1, metadatas[i]);
 	}
 
@@ -138,14 +143,24 @@ static VALUE read_metadata (STATE)
 	return result;
 }
 
-static VALUE read_nil (STATE)
+static VALUE read_symbol (STATE)
 {
-	if (!IS_NOT_EOF_UP_TO(3)) {
-		rb_raise(rb_eSyntaxError, "unexpected EOF");
+	size_t length = 0;
+
+	while (IS_SYMBOL(AFTER(length))) {
+		length++;
 	}
 
-	if (!IS_EQUAL_UP_TO("nil", 3)) {
-		rb_raise(rb_eSyntaxError, "expected nil, got n%c%c", AFTER(1), AFTER(2));
+	SEEK(length);
+
+	return rb_funcall(rb_funcall(rb_str_new(BEFORE_PTR(length), length), rb_intern("to_sym"), 0),
+		rb_intern("symbol!"), 0);
+}
+
+static VALUE read_nil (STATE)
+{
+	if (!IS_NOT_EOF_UP_TO(3) || !IS_EQUAL_UP_TO("nil", 3) || !IS_BOTH_SEPARATOR(AFTER(3))) {
+		return CALL(read_symbol);
 	}
 
 	SEEK(3);
@@ -156,25 +171,17 @@ static VALUE read_nil (STATE)
 static VALUE read_boolean (STATE)
 {
 	if (CURRENT == 't') {
-		if (!IS_NOT_EOF_UP_TO(4)) {
-			rb_raise(rb_eSyntaxError, "unexpected EOF");
+		if (!IS_NOT_EOF_UP_TO(4) || !IS_EQUAL_UP_TO("true", 4) || !IS_BOTH_SEPARATOR(AFTER(4))) {
+			return CALL(read_symbol);
 		}
-
-		if (!IS_EQUAL_UP_TO("true", 4)) {
-			rb_raise(rb_eSyntaxError, "expected true, got t%c%c%c", AFTER(1), AFTER(2), AFTER(3));
-		}
-
+		
 		SEEK(4);
 
 		return Qtrue;
 	}
 	else {
-		if (!IS_NOT_EOF_UP_TO(5)) {
-			rb_raise(rb_eSyntaxError, "unexpected EOF");
-		}
-
-		if (!IS_EQUAL_UP_TO("false", 5)) {
-			rb_raise(rb_eSyntaxError, "expected false, got f%c%c%c%c", AFTER(1), AFTER(2), AFTER(3), AFTER(4));
+		if (!IS_NOT_EOF_UP_TO(5) || !IS_EQUAL_UP_TO("false", 5) || !IS_BOTH_SEPARATOR(AFTER(5))) {
+			return CALL(read_symbol);
 		}
 
 		SEEK(5);
@@ -190,7 +197,7 @@ static VALUE read_number (STATE)
 	char*  cPiece;
 	char*  tmp;
 
-	while (!IS_EOF_AFTER(length) && !IS_BOTH(AFTER(length))) {
+	while (!IS_EOF_AFTER(length) && !IS_BOTH_SEPARATOR(AFTER(length))) {
 		length++;
 	}
 
@@ -227,50 +234,49 @@ static VALUE read_char (STATE)
 {
 	SEEK(1);
 
-	if (IS_EOF_AFTER(1) || IS_BOTH(AFTER(1))) {
+	if (IS_EOF_AFTER(1) || IS_BOTH_SEPARATOR(AFTER(1))) {
 		SEEK(1); return rb_str_new(BEFORE_PTR(1), 1);
 	}
-	else if (IS_NOT_EOF_UP_TO(7) && IS_EQUAL_UP_TO("newline", 7) && (IS_EOF_AFTER(7) || IS_BOTH(AFTER(7)))) {
+	else if (IS_NOT_EOF_UP_TO(7) && IS_EQUAL_UP_TO("newline", 7) && IS_BOTH_SEPARATOR(AFTER(7))) {
 		SEEK(7); return rb_str_new2("\n");
 	}
-	else if (IS_NOT_EOF_UP_TO(5) && IS_EQUAL_UP_TO("space", 5) && (IS_EOF_AFTER(5) || IS_BOTH(AFTER(5)))) {
+	else if (IS_NOT_EOF_UP_TO(5) && IS_EQUAL_UP_TO("space", 5) && IS_BOTH_SEPARATOR(AFTER(5))) {
 		SEEK(5); return rb_str_new2(" ");
 	}
-	else if (IS_NOT_EOF_UP_TO(3) && IS_EQUAL_UP_TO("tab", 3) && (IS_EOF_AFTER(3) || IS_BOTH(AFTER(3)))) {
+	else if (IS_NOT_EOF_UP_TO(3) && IS_EQUAL_UP_TO("tab", 3) && IS_BOTH_SEPARATOR(AFTER(3))) {
 		SEEK(3); return rb_str_new2("\t");
 	}
-	else if (IS_NOT_EOF_UP_TO(9) && IS_EQUAL_UP_TO("backspace", 9) && (IS_EOF_AFTER(9) || IS_BOTH(AFTER(9)))) {
+	else if (IS_NOT_EOF_UP_TO(9) && IS_EQUAL_UP_TO("backspace", 9) && IS_BOTH_SEPARATOR(AFTER(9))) {
 		SEEK(9); return rb_str_new2("\b");
 	}
-	else if (IS_NOT_EOF_UP_TO(8) && IS_EQUAL_UP_TO("formfeed", 8) && (IS_EOF_AFTER(8) || IS_BOTH(AFTER(8)))) {
+	else if (IS_NOT_EOF_UP_TO(8) && IS_EQUAL_UP_TO("formfeed", 8) && IS_BOTH_SEPARATOR(AFTER(8))) {
 		SEEK(8); return rb_str_new2("\f");
 	}
-	else if (IS_NOT_EOF_UP_TO(6) && IS_EQUAL_UP_TO("return", 6) && (IS_EOF_AFTER(6) || IS_BOTH(AFTER(6)))) {
+	else if (IS_NOT_EOF_UP_TO(6) && IS_EQUAL_UP_TO("return", 6) && IS_BOTH_SEPARATOR(AFTER(6))) {
 		SEEK(6); return rb_str_new2("\r");
 	}
-	else if (CURRENT == 'u' && IS_NOT_EOF_UP_TO(5) && !NIL_P(rb_funcall(rb_str_new(AFTER_PTR(1), 4), rb_intern("=~"), 1, UNICODE_REGEX)) && (IS_EOF_AFTER(5) || IS_BOTH(AFTER(5)))) {
+	else if (CURRENT == 'u' && IS_NOT_EOF_UP_TO(5) && !NIL_P(rb_funcall(rb_str_new(AFTER_PTR(1), 4), rb_intern("=~"), 1, UNICODE_REGEX)) && IS_BOTH_SEPARATOR(AFTER(5))) {
 		SEEK(5); return rb_funcall(rb_ary_new3(1, rb_funcall(rb_str_new(BEFORE_PTR(4), 4), rb_intern("to_i"), 1, INT2FIX(16))),
 			rb_intern("pack"), 1, rb_str_new2("U"));
 	}
 	else if (CURRENT == 'o') {
 		size_t length = 1;
+		size_t i;
 
-		for (size_t i = 1; i < 5; i++) {
-			if (IS_EOF_AFTER(i) || IS_BOTH(AFTER(i))) {
+		for (i = 1; i < 5; i++) {
+			if (IS_BOTH_SEPARATOR(AFTER(i))) {
 				break;
 			}
 
 			length++;
 		}
 
-		if (length > 1 && !NIL_P(rb_funcall(rb_str_new(AFTER_PTR(1), length - 1), rb_intern("=~"), 1, OCTAL_REGEX)) && (IS_EOF_AFTER(length) || IS_BOTH(AFTER(length)))) {
+		if (length > 1 && !NIL_P(rb_funcall(rb_str_new(AFTER_PTR(1), length - 1), rb_intern("=~"), 1, OCTAL_REGEX)) && IS_BOTH_SEPARATOR(AFTER(length))) {
 			SEEK(length); return rb_funcall(rb_funcall(rb_str_new(BEFORE_PTR(length - 1), length - 1), rb_intern("to_i"), 1, INT2FIX(8)),
 				rb_intern("chr"), 0);
 		}
 	}
 
-	// TODO: add unicode and octal chars support
-
 	rb_raise(rb_eSyntaxError, "unknown character type");
 }
 
@@ -280,13 +286,14 @@ static VALUE read_keyword (STATE)
 
 	SEEK(1);
 
-	while (!IS_EOF_AFTER(length) && !IS_KEYWORD(AFTER(length))) {
+	while (!IS_KEYWORD_SEPARATOR(AFTER(length))) {
 		length++;
 	}
 
 	SEEK(length);
 
-	return rb_funcall(rb_str_new(BEFORE_PTR(length), length), rb_intern("to_sym"), 0);
+	return rb_funcall(rb_funcall(rb_str_new(BEFORE_PTR(length), length), rb_intern("to_sym"), 0),
+		rb_intern("keyword!"), 0);
 }
 
 static VALUE read_string (STATE)
@@ -309,8 +316,6 @@ static VALUE read_string (STATE)
 
 	SEEK(length + 1);
 
-	// TODO: make the escapes work properly
-
 	return rb_funcall(cClojure, rb_intern("unescape"), 1, rb_str_new(BEFORE_PTR(length + 1), length));
 }
 
@@ -457,6 +462,7 @@ static VALUE read_next (STATE)
 		case NODE_INSTANT:  return CALL(read_instant);
 		case NODE_SET:      return CALL(read_set);
 		case NODE_REGEXP:   return CALL(read_regexp);
+		case NODE_SYMBOL:   return CALL(read_symbol);
 	}
 }
 

data/lib/clj/parser.rb

@@ -13,7 +13,8 @@ require 'stringio'
 module Clojure
 
 class Parser
-	NUMBERS = '0' .. '9'
+	NUMBERS  = '0' .. '9'
+	SYMBOL   = ('0' .. '9').to_a | ('a' .. 'z').to_a | ('A' .. 'Z').to_a | %w[+ ! - _ ? . : /]
 
 	UNICODE_REGEX = /[0-9|a-f|A-F]{4}/
 	OCTAL_REGEX   = /[0-3]?[0-7]?[0-7]/
@@ -29,7 +30,15 @@ class Parser
 	end
 
 	def parse
-		read_next
+		result = read_next
+
+		ignore(false)
+
+		if @source.read(1)
+			raise SyntaxError, 'there is some unconsumed input'
+		end
+
+		result
 	end
 
 private
@@ -51,7 +60,8 @@ private
 			when '{' then :set
 			when '"' then :regexp
 			end
-		end or raise SyntaxError, 'unknown type'
+		else :symbol
+		end
 	end
 
 	def read_next
@@ -83,45 +93,39 @@ private
 	end
 
 	def read_nil (ch)
-		check = @source.read(2)
+		check = @source.read(3)
 
-		if check.length != 2
-			raise SyntaxError, 'unexpected EOF'
-		elsif check != 'il'
-			raise SyntaxError, "expected nil, found n#{check}"
+		if check[0, 2] != 'il' || !both_separator?(check[2])
+			revert(check.length) and read_symbol(ch)
+		else
+			nil
 		end
-
-		nil
 	end
 
 	def read_boolean (ch)
 		if ch == 't'
-			check = @source.read(3)
+			check = @source.read(4)
 
-			if check.length != 3
-				raise SyntaxError, 'unexpected EOF'
-			elsif check != 'rue'
-				raise SyntaxError, "expected true, found t#{check}"
+			if check[0, 3] != 'rue' || !both_separator?(check[3])
+				revert(check.length) and read_symbol(ch)
+			else
+				true
 			end
-
-			true
 		else
-			check = @source.read(4)
+			check = @source.read(5)
 
-			if check.length != 4
-				raise SyntaxError, 'unexpected EOF'
-			elsif check != 'alse'
-				raise SyntaxError, "expected false, found f#{check}"
+			if check[0, 4] != 'alse' || !both_separator?(check[4])
+				revert(check.length) and read_symbol(ch)
+			else
+				false
 			end
-
-			false
 		end
 	end
 
 	def read_number (ch)
 		piece = ch
 
-		while (ch = @source.read(1)) && !both?(ch)
+		while (ch = @source.read(1)) && !both_separator?(ch)
 			piece << ch
 		end
 
@@ -149,41 +153,57 @@ private
 	end
 
 	def read_char (ch)
-		if (ahead = lookahead(2)) && (!ahead[1] || both?(ahead[1]))
+		if (ahead = lookahead(2)) && both_separator?(ahead[1])
 			@source.read(1)
-		elsif (ahead = lookahead(8)) && ahead[0, 7] == 'newline' && (!ahead[7] || both?(ahead[7]))
+		elsif (ahead = lookahead(8)) && ahead[0, 7] == 'newline' && both_separator?(ahead[7])
 			@source.read(7) and "\n"
-		elsif (ahead = lookahead(6)) && ahead[0, 5] == 'space' && (!ahead[5] || both?(ahead[5]))
+		elsif (ahead = lookahead(6)) && ahead[0, 5] == 'space' && both_separator?(ahead[5])
 			@source.read(5) and ' '
-		elsif (ahead = lookahead(4)) && ahead[0, 3] == 'tab' && (!ahead[3] || both?(ahead[3]))
+		elsif (ahead = lookahead(4)) && ahead[0, 3] == 'tab' && both_separator?(ahead[3])
 			@source.read(3) and "\t"
-		elsif (ahead = lookahead(10)) && ahead[0, 9] == 'backspace' && (!ahead[9] || both?(ahead[9]))
+		elsif (ahead = lookahead(10)) && ahead[0, 9] == 'backspace' && both_separator?(ahead[9])
 			@source.read(9) and "\b"
-		elsif (ahead = lookahead(9)) && ahead[0, 8] == 'formfeed' && (!ahead[8] || both?(ahead[8]))
+		elsif (ahead = lookahead(9)) && ahead[0, 8] == 'formfeed' && both_separator?(ahead[8])
 			@source.read(8) and "\f"
-		elsif (ahead = lookahead(7)) && ahead[0, 6] == 'return' && (!ahead[6] || both?(ahead[6]))
+		elsif (ahead = lookahead(7)) && ahead[0, 6] == 'return' && both_separator?(ahead[6])
 			@source.read(6) and "\r"
-		elsif (ahead = lookahead(6)) && ahead[0] == 'u' && ahead[1, 5] =~ UNICODE_REGEX && (!ahead[5] || both?(ahead[5]))
+		elsif (ahead = lookahead(6)) && ahead[0] == 'u' && ahead[1, 5] =~ UNICODE_REGEX && both_separator?(ahead[5])
 			[@source.read(5)[1, 4].to_i(16)].pack('U')
 		elsif (ahead = lookahead(5)) && ahead[0] == 'o' && matches = ahead[1, 3].match(OCTAL_REGEX)
 			length = matches[0].length + 1
 
-			if !ahead[length] || both?(ahead[length])
+			if both_separator?(ahead[length])
 				@source.read(length)[1, 3].to_i(8).chr
 			end
 		end or raise SyntaxError, 'unknown character type'
 	end
 
+	def read_symbol (ch)
+		result = ch
+
+		while (ch = @source.read(1)) && is_symbol?(ch)
+			result << ch
+		end
+
+		revert if ch
+
+		if result.include? '::'
+			raise SyntaxError, 'symbols cannot have repeating :'
+		end
+
+		result.to_sym.symbol!
+	end
+
 	def read_keyword (ch)
 		result = ''
 
-		while (ch = @source.read(1)) && !keyword?(ch)
+		while (ch = @source.read(1)) && !keyword_separator?(ch)
 			result << ch
 		end
 
 		revert if ch
 
-		result.to_sym
+		result.to_sym.keyword!
 	end
 
 	def read_string (ch)
@@ -321,12 +341,16 @@ private
 		ch == ' ' || ch == ',' || ch == "\n" || ch == "\r" || ch == "\t"
 	end
 
-	def both? (ch)
-		ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "\n" || ch == "\r" || ch == "\t"
+	def is_symbol? (ch)
+		SYMBOL.include?(ch)
+	end
+
+	def both_separator? (ch)
+		ch == nil || ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "\n" || ch == "\r" || ch == "\t"
 	end
 
-	def keyword? (ch)
-		ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "'" || ch == '^' || ch == '@' || ch == '`' || ch == '~' || ch == '\\' || ch == ';' || ch == "\n" || ch == "\r" || ch == "\t"
+	def keyword_separator? (ch)
+		ch == nil || ch == ' ' || ch == ',' || ch == '"' || ch == '{' || ch == '}' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '#' || ch == ':' || ch == "'" || ch == '^' || ch == '@' || ch == '`' || ch == '~' || ch == '\\' || ch == ';' || ch == "\n" || ch == "\r" || ch == "\t"
 	end
 end
 

data/lib/clj/types.rb

@@ -8,6 +8,8 @@
 #  0. You just DO WHAT THE FUCK YOU WANT TO.
 #++
 
+require 'forwardable'
+
 module Clojure
 	module Metadata
 		def metadata
@@ -73,6 +75,35 @@ module Clojure
 			metadata_to_clj(options) + '#{' + uniq.map { |o| o.to_clj(options) }.join(' ') + '}'
 		end
 	end
+
+	class Symbol
+		def initialize (sym)
+			@internal = sym
+		end
+
+		def keyword?; false; end
+		def symbol?;  true;  end
+
+		def to_clj (*)
+			result = to_sym.to_s
+
+			unless result =~ %r([\w:+!-_?./][\w\d:+!-_?./]*)
+				raise ArgumentError, "#{result} cannot be transformed into clojure"
+			end
+
+			result
+		end
+
+		def == (other)
+			return false unless other.is_a?(Symbol)
+
+			to_sym == other.to_sym
+		end
+
+		def to_sym;  @internal;    end
+		def to_s;    to_sym.to_s;  end
+		def inspect; to_s          end
+	end
 end
 
 [Numeric, TrueClass, FalseClass, NilClass].each {|klass|
@@ -84,8 +115,19 @@ end
 }
 
 class Symbol
-	def to_clj (options = {})
-		result = inspect
+	def keyword!
+		self
+	end
+
+	def symbol!
+		Clojure::Symbol.new(self)
+	end
+
+	def keyword?; true;  end
+	def symbol?;  false; end
+
+	def to_clj (*)
+		result = to_sym.inspect
 
 		unless result =~ /:([^(\[{'^@`~\"\\,\s;)\]}]+)/
 			raise ArgumentError, "#{result} cannot be transformed into clojure"
@@ -96,12 +138,8 @@ class Symbol
 end
 
 class String
-	def to_clj (options = {})
-		result = if respond_to? :encode
-			encode('UTF-16be').inspect
-		else
-			inspect
-		end
+	def to_clj (*)
+		result = (encode('UTF-16be') rescue self).inspect
 		
 		result.gsub!(/(^|[^\\])\\e/, '\1\u001b')
 		result.gsub!(/(^|[^\\])\\a/, '\1\u0003')
@@ -111,13 +149,13 @@ class String
 end
 
 class Rational
-	def to_clj (options = {})
+	def to_clj (*)
 		to_s
 	end
 end
 
 class Regexp
-	def to_clj (options = {})
+	def to_clj (*)
 		'#"' + inspect[1 .. -2] + '"'
 	end
 end
@@ -141,13 +179,13 @@ class Time
 end
 
 class Bignum < Integer
-	def to_clj (options = {})
+	def to_clj (*)
 		to_s + 'N'
 	end
 end
 
 class BigDecimal < Numeric
-	def to_clj (options = {})
+	def to_clj (*)
 		to_s('F') + 'M'
 	end
 end

data/lib/clj.rb

@@ -71,8 +71,10 @@ end
 
 require 'clj/types'
 
-if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+begin
+	raise LoadError if RUBY_ENGINE == 'jruby'
+
 	require 'clj/parser_ext'
-else
+rescue LoadError
 	require 'clj/parser'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clj
 version: !ruby/object:Gem::Version
-  version: 0.0.6.1
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-01 00:00:00.000000000 Z
+date: 2012-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &7244020 !ruby/object:Gem::Requirement
+  requirement: &17788760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *7244020
+  version_requirements: *17788760
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &7243040 !ruby/object:Gem::Requirement
+  requirement: &18290880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *7243040
+  version_requirements: *18290880
 description: 
 email: meh@paranoici.org
 executables: []