theta 0.1.3 → 0.1.4

data/README.rdoc

@@ -1,6 +1,6 @@
 = Theta
 
-Theta is a Lisp interpreter for Ruby.  It was heavily influenced by {lis.py}[http://norvig.com/lispy.html] and {flea}[https://github.com/aarongough/flea].  It was primarily made as a learning exercise.
+Theta is a Lisp interpreter for Ruby (though it's really just a small subset of Lisp it interprets).  It was heavily influenced by {lis.py}[http://norvig.com/lispy.html] and {flea}[https://github.com/aarongough/flea].  It was primarily made as a learning exercise.
 
 == How to use
 
@@ -12,7 +12,6 @@ After installation, simply type theta to get to the interactive interpreter prom
 
 	% theta
 	theta> (define a 2)
-	2
 	theta> (+ a 3)
 	5
 	theta> (define square (lambda (x) (* x x)))
@@ -37,3 +36,77 @@ And finally, you can use Theta inside your own Ruby programs, if that sounds lik
 	t = Theta::Interpreter.new
 	t.run "(define n 15)"
 	puts t.run "(+ 10 n)"	
+	
+== Syntax
+
+Theta uses a very simplified Lisp-like syntax.
+
+=== Math
+
+Theta has your basic mathematical functions.
+
+	theta> (+ 2 2)
+	4
+	theta> (- 3 2)
+	1
+	theta> (* 4 2)
+	8
+	theta> (/ 4 2)
+	2
+	
+=== Defining Functions and Variables
+
+You also have the basic variable definition stuff.
+
+	theta> (define a 2)
+	theta> (+ a 3)
+	5
+	
+And functions.
+
+	theta> (define square (lambda (x) (* x x)))
+	theta> (square 3)
+	9
+	
+=== Conditionals and Truthiness
+
+We have your basic if statement that will evaluate the first piece of code 
+if true, otherwise the second (if you give it one).
+
+	theta> (if (= 2 2) (display "true") (display "not true"))
+	true
+	theta> (if (= 1 2) (display "true") (display "not true"))
+	not true
+	
+And some basic Boolean statements.
+
+	theta> (= 2 2)
+	true
+	theta> (> 1 2)
+	false
+	theta> (< 2 3)
+	true
+	theta> (>= 3 3 2)
+	true
+	theta> (<= 4 5 2)
+	false
+
+=== Input and Output
+
+Theta also has basic input and output.
+
+	theta> (display "poop")
+	poop
+	theta> (define a (input))
+	hi <this is user input>
+	theta> (display a)
+	hi
+	
+And a function to turn user input into an integer.
+
+	theta> (define a (string-to-num (input)))
+	123 <this is user input>
+	theta>(+ a 3)
+	126
+	
+	

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/lib/theta.rb

@@ -16,7 +16,10 @@ module Theta
 		
 		# run given code
 		def run(program)
-			puts @interpreter.run(program)
+			output =  @interpreter.run(program)
+			if not output.nil? and not output.empty? 
+				output.each { |value| puts @interpreter.make_readable(value) }
+			end
 		end
 		
 		# start an interactive interpreter
@@ -36,11 +39,11 @@ module Theta
 					repl_help
 				else
 					begin
-						value = @interpreter.run(input)
+						output = @interpreter.run(input)
 					rescue SyntaxError
 					end
-					unless value.nil?
-						puts @interpreter.make_readable(value)
+					if not output.nil? and not output.empty? 
+						output.each { |value| puts @interpreter.make_readable(value) }
 					end
 				end
 			end

data/lib/theta/environment.rb

@@ -9,8 +9,8 @@ module Theta
 			@parent = parent
 			@table = {}
 			if @parent.nil?
-				define(":#t", true)
-				define(":#f", false)
+				define("#t".to_sym, true)
+				define("#f".to_sym, false)
 			end
 		end
 

data/lib/theta/interpreter.rb

@@ -28,7 +28,9 @@ module Theta
 		# run some code
 		def run(program)
 			expression = parse(program)
-			return evaluate(expression)
+			output = []
+			expression.each { |e| output << evaluate(e) }
+			return output.delete_if { |x| x.nil? }
 		end
 
 		# call the parser to make a string interpretable
@@ -49,17 +51,9 @@ module Theta
 				return expression
 			end
 
-			if expression.count == 1
-				if expression.is_a? Symbol
-					return @current_environment.find(expression[0])
-				else
-					return expression[0]
-				end
-			end
-
 			case expression[0]
 			when :define
-				return @current_environment.define(expression [1], evaluate(expression[2]))
+				@current_environment.define(expression [1], evaluate(expression[2]))
 			when :ruby_func
 				return eval expression[1]
 			else
@@ -71,6 +65,7 @@ module Theta
 					raise RuntimeError, "#{expression[0]} is not a function"
 				end
 			end
+			return nil
 		end
 	end
 end

data/lib/theta/library/display.scm

@@ -0,0 +1,8 @@
+(define display
+	(ruby_func "
+		lambda { |arguments, interpreter|
+			output = interpreter.evaluate(arguments[0])
+			puts interpreter.make_readable(output)
+		}
+	")
+)

data/lib/theta/library/equality.scm

@@ -6,6 +6,7 @@
 					return false
 				end
 			end
+			return true
 		}
 	")
 )

data/lib/theta/library/input.scm

@@ -0,0 +1,7 @@
+(define input
+	(ruby_func " 
+		lambda { |arguments, interpreter|
+			gets
+		}
+	")
+)

data/lib/theta/library/string-to-num.scm

@@ -0,0 +1,7 @@
+(define string-to-num
+	(ruby_func "
+		lambda { |arguments, interpreter|
+			interpreter.evaluate(arguments[0]).to_i
+		}
+	")
+)

data/lib/theta/parser.rb

@@ -73,26 +73,49 @@ module Theta
 				raise SyntaxError, "unexpected EOF while reading"
 			end
 			tokens.delete_if { |item| item.strip == "" || item == []}
-			token = tokens.shift
-			if "(" == token
-				l = []
-				until tokens[0] == ")"
-					l << read_from(tokens)
+			tmp, expression = restructure tokens
+			return expression
+		end	
+			
+		def restructure(token_array, offset = 0)
+			statement = []
+			while offset < token_array.length
+				if token_array[offset] == "("
+					offset, tmp_array = restructure(token_array, offset + 1)
+					statement << tmp_array
+				elsif token_array[offset] == ")"
+					break
+				else
+					statement << atom(token_array[offset])
 				end
-				tokens.shift
-				return l
-			elsif ")" == token
-				raise SyntaxError, "unexpected )"
-			elsif token.start_with?("\"")
-				return token.gsub("\"", "")
-			else
-				return atom(token)
+				offset += 1
 			end
+			return offset, statement
 		end
+			
+#			token = tokens.shift
+#			if "(" == token
+#				l = []
+#				until tokens[0] == ")"
+#					l << read_from(tokens)
+#				end
+#				tokens.shift
+#				return l
+#			elsif ")" == token
+#				raise SyntaxError, "unexpected )"
+#			elsif token.start_with?("\"")
+#				return token.gsub("\"", "")
+#			else
+#				return atom(token)
+#			end
+#		end
 
 		# returns appropriate numeric object if a number, 
 		# otherwise returns a symbol
 		def atom(token)
+			if token.start_with?("\"")
+				return token.gsub("\"", "")
+			end
 			token.gsub!(/\n\t/, "")
 			begin
 				return Integer(token)
@@ -108,7 +131,8 @@ module Theta
 		# convert an expression back to a readable string
 		def to_string(expression)
 			if expression.is_a? Array
-				return "(" + " ".join(expression.map { |exp| to_string(exp) }) + ")"
+				expression.map { |exp| to_string(exp) }
+				return "(" + expression.join(" ") + ")"
 			else
 				return expression.to_s
 			end

data/test/library/test_add.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestAdd < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "add numbers correctly" do
+			result = @interpreter.run("(+ 2 2)")
+			assert_equal(4, result[0])
+		end
+		
+		should "add a series of numbers" do
+			result = @interpreter.run("(+ 5 4 3 2 1)")
+			assert_equal(15, result[0])
+		end
+		
+		should "add defined variables" do
+			result = @interpreter.run(
+			"(define a 1)
+			 (define b 2)
+			 (+ a b)")
+			assert_equal(3, result[0])
+		end
+	end
+end

data/test/library/test_divide.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestDivide < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+
+		should "divide numbers properly" do
+			result = @interpreter.run("(/ 10 2)")
+			assert_equal(5, result[0])
+		end
+		
+		should "divide multiple numbers" do
+			result = @interpreter.run("(/ 4 2 2)")
+			assert_equal(1, result[0])
+		end
+		
+		should "divide defined variables" do
+			result = @interpreter.run(
+			"(define a 4)
+			 (define b 2)
+			 (/ a b)")
+			assert_equal(2, result[0])
+		end
+		
+		should "properly round for integer division" do
+			result = @interpreter.run("(/ 5 2)")
+			assert_equal(2, result[0])
+		end
+		
+		should "not round for float division" do
+			result = @interpreter.run("(/ 5.0 2)")
+			assert_equal(2.5, result[0])
+		end
+	end
+end

data/test/library/test_equality.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestEquality < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "return true for correct expressions" do
+			result = @interpreter.run("(= 2 2)")
+			assert_equal(true, result[0])
+		end
+		
+		should "return false for incorrect expressions" do
+			result = @interpreter.run("(= 2 3)")
+			assert_equal(false, result[0])
+		end
+		
+		should "work with multiple arguments" do
+			result = @interpreter.run("
+				(= 2 2 2)
+				(= 2 2 3 2)
+			")
+			assert_equal(true, result[0])
+			assert_equal(false, result[1])
+		end
+		
+		should "work with variables" do
+			@interpreter.run("
+				(define a 1)
+				(define b 2)
+			")
+			result = @interpreter.run("
+				(= a a)
+				(= a b)
+			")
+			assert_equal(true, result[0])
+			assert_equal(false, result[1])
+		end
+	end
+end

data/test/library/test_greater_than.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestGreaterThan < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "return true if first arg is largest" do
+			result = @interpreter.run("(> 5 1 2 3)")
+			assert_equal(true, result[0])
+		end
+		
+		should "return false if first arg isn't largest" do
+			result = @interpreter.run("(> 5 1 2 10)")
+			assert_equal(false, result[0])
+		end
+		
+		should "work with variables" do
+			@interpreter.run("
+				(define a 1)
+				(define b 2)
+				(define c 3)
+			")
+			result = @interpreter.run("
+				(> c b a)
+				(> b a c)
+			")
+			assert_equal(true, result[0])
+			assert_equal(false, result[1])
+		end
+	end
+end

data/test/library/test_greater_than_or_equal.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestGreaterThanOrEqual < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "return true if first arg is largest" do
+			result = @interpreter.run("(>= 4 3 2)")
+			assert_equal(true, result[0])
+		end
+		
+		should "return true if first arg is equal to the largest" do
+			result = @interpreter.run("(>= 4 3 2 4)")
+			assert_equal(true, result[0])
+		end
+		
+		should "return false if first arg is not greater than or equal to the largest" do
+			result = @interpreter.run("(>= 4 3 2 10)")
+			assert_equal(false, result[0])
+		end
+		
+		should "work with variables" do
+			@interpreter.run("
+				(define a 1)
+				(define b 2)
+				(define c 3)
+			")
+			result = @interpreter.run("
+				(>= c b a)
+				(>= c b a c)
+				(>= b c a)
+			")
+			assert_equal(true, result[0])
+			assert_equal(true, result[1])
+			assert_equal(false, result[2])
+		end
+	end
+end

data/test/library/test_if.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestIf < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		context "without else" do
+			should "execute statement if true" do
+				@interpreter.run("
+					(if #t
+						(define a 1))
+				")
+				assert_equal(1, @interpreter.current_environment.find(:a))
+			end
+			
+			should "not execute statement if false" do
+				@interpreter.run("
+					(if #f
+						(define a 1))
+				")
+				assert_equal(nil, @interpreter.current_environment.find(:a))
+			end
+		end
+		
+		context "with else" do
+			should "execute else statement if false" do
+				@interpreter.run("
+					(if #f
+						(define a 1)
+						(define b 1))
+				")
+				assert_equal(nil, @interpreter.current_environment.find(:a))
+				assert_equal(1, @interpreter.current_environment.find(:b))
+			end
+			
+			should "not execute else statement if true" do
+				@interpreter.run("
+					(if #t
+						(define a 1)
+						(define b 1))
+				")
+				assert_equal(1, @interpreter.current_environment.find(:a))
+				assert_equal(nil, @interpreter.current_environment.find(:b))
+			end
+		end
+	end
+end

data/test/library/test_lambda.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestLambda < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "create a function" do
+			result = @interpreter.run("
+				(lambda () ())
+			")
+			assert_kind_of(Proc, result[0])
+		end
+
+		should "accept an argument" do
+			result = @interpreter.run("
+				(define test (lambda (a) (+ a a)))
+				(test 1)
+			")
+			assert_equal(2, result[0])
+		end
+		
+		should "accept multiple arguments" do
+			result = @interpreter.run("
+				(define test (lambda (a b c) (+ a b c)))
+				(test 1 2 3)
+			")
+			assert_equal(6, result[0])
+		end
+		
+		should "raise an error if a param is used more than once" do
+			assert_raise(RuntimeError) {
+				@interpreter.run("
+					(lambda (a a) (+ a 2))
+				")
+			}
+		end
+	end
+end

data/test/library/test_less_than.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestLessThan < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "return true if first arg is smallest" do
+			result = @interpreter.run("(< 1 2 3)")
+			assert_equal(true, result[0])
+		end
+		
+		should "return false if first arg isn't smallest" do
+			result = @interpreter.run("(< 5 2 10)")
+			assert_equal(false, result[0])
+		end
+		
+		should "work with variables" do
+			@interpreter.run("
+				(define a 1)
+				(define b 2)
+				(define c 3)
+			")
+			result = @interpreter.run("
+				(< a b c)
+				(< b a c)
+			")
+			assert_equal(true, result[0])
+			assert_equal(false, result[1])
+		end
+	end
+end

data/test/library/test_less_than_or_equal.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestGreaterThanOrEqual < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "return true if first arg is smallest" do
+			result = @interpreter.run("(<= 1 3 2)")
+			assert_equal(true, result[0])
+		end
+		
+		should "return true if first arg is equal to the smallest" do
+			result = @interpreter.run("(<= 2 3 2 4)")
+			assert_equal(true, result[0])
+		end
+		
+		should "return false if first arg is not less than or equal to the smallest" do
+			result = @interpreter.run("(<= 4 3 2 10)")
+			assert_equal(false, result[0])
+		end
+		
+		should "work with variables" do
+			@interpreter.run("
+				(define a 1)
+				(define b 2)
+				(define c 3)
+			")
+			result = @interpreter.run("
+				(<= a b c)
+				(<= a b a c)
+				(<= b c a)
+			")
+			assert_equal(true, result[0])
+			assert_equal(true, result[1])
+			assert_equal(false, result[2])
+		end
+	end
+end

data/test/library/test_multiply.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestMultiply < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "multiply numbers properly" do
+			result = @interpreter.run("(* 2 2)")
+			assert_equal(4, result[0])
+		end
+		
+		should "multiply multiple numbers" do
+			result = @interpreter.run("(* 2 3 4)")
+			assert_equal(24, result[0])
+		end
+		
+		should "multiply defined variables" do
+			result = @interpreter.run(
+			"(define a 4)
+			 (define b 2)
+			 (* a b)")
+			assert_equal(8, result[0])
+		end
+	end
+end

data/test/library/test_set.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestSet < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "set value of existing variable" do
+			@interpreter.run("
+				(define a 1)
+				(set! a 2)
+			")
+			assert_equal(2, @interpreter.current_environment.find(:a))
+		end
+		
+		should "raise an error if variable not defined" do
+			assert_raise(TypeError) { @interpreter.run("(set! a 2)") }
+		end
+	end
+end

data/test/library/test_subtract.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper.rb"))
+
+module Theta
+	class TestSubtract < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		should "subtract numbers properly" do
+			result = @interpreter.run("(- 10 5)")
+			assert_equal(5, result[0])
+		end
+		
+		should "subtract multiple numbers" do
+			result = @interpreter.run("(- 20 1 2 3 4 5)")
+			assert_equal(5, result[0])
+		end
+		
+		should "subtract defined variables" do
+			result = @interpreter.run(
+			"(define a 4)
+			 (define b 2)
+			 (- a b)")
+			assert_equal(2, result[0])
+		end
+	end
+end

data/test/test_environment.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+module Theta
+	class TestEnvironment < Test::Unit::TestCase
+		def setup
+			@environment = Environment.new
+		end
+		
+		context "new" do
+			should "add definition for true" do
+				result = @environment.find("#t".to_sym)
+				assert_equal(true, result)
+			end
+			
+			should "add definition for false" do
+				result = @environment.find("#f".to_sym)
+				assert_equal(false, result)
+			end
+		end
+		
+		context "find" do
+			should "return nil for undefined item" do
+				result = @environment.find(:a)
+				assert_equal(nil, result)
+			end
+			
+			should "return defined item" do
+				@environment.define(:a, 1)
+				result = @environment.find(:a)
+				assert_equal(1, result)
+			end
+			
+			should "return item defined in parent" do
+				@environment.define(:a, 1)
+				child = Environment.new(@environment)
+				result = child.find(:a)
+				assert_equal(1, result)
+			end
+			
+			should "override a variable in parent if defined in current" do
+				@environment.define(:a, 1)
+				child = Environment.new(@environment)
+				child.define(:a, 3)
+				result = child.find(:a)
+				assert_equal(3, result)
+			end
+		end
+	end
+end

data/test/test_interpreter.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+module Theta
+	class TestInterpreter < Test::Unit::TestCase
+		def setup
+			@interpreter = Interpreter.new
+		end
+		
+		context "run" do
+			should "run code and return a result" do
+				result = @interpreter.run("(+ 0 1)")
+				assert_equal(1, result[0])
+			end
+		end
+		
+		context "evaluate" do
+			should "allow definition of items" do
+				@interpreter.evaluate([:define, :a, 1])
+				assert_equal(1, @interpreter.current_environment.find(:a))
+			end
+			
+			should "allow ruby functions" do
+				result = @interpreter.evaluate([:ruby_func,
+				"lambda { 1 }"])
+				assert_equal(1, result.call)
+			end
+		end
+	end
+end

data/test/test_parser.rb

@@ -0,0 +1,59 @@
+require 'helper'
+
+module Theta
+	class TestParser < Test::Unit::TestCase
+		def setup
+			@parser = Parser.new
+		end
+		
+		context "atom" do
+			should "convert string to symbol" do
+				result = @parser.atom("test")
+				assert_equal(:test, result)
+			end
+			
+			should "leave numbers alone" do
+				result = @parser.atom("1")
+				assert_equal(1, result)
+			end
+		end
+		
+		context "tokenize" do
+			should "split a statement apart into its component pieces" do
+				result = @parser.tokenize("(define a 1)")
+				assert_equal(["(", "define", "a", "1", ")"], result)
+			end
+			
+			should "be able to handle multiple statements at a time" do	
+				result = @parser.tokenize("(define a 1) (define b 2)")
+				assert_equal(["(", "define", "a", "1", ")","(", "define", "b", "2", ")"], result)
+			end
+		end
+		
+		context "read_from" do
+			should "turn a tokenized statement into an interpreter understandable array" do
+				result = @parser.read_from(["(", "define", "a", "1", ")"])
+				assert_equal([[:define, :a, 1]], result)
+			end
+			
+			should "be able to handle multiple statements at a time" do
+				tokens = @parser.tokenize("(define a 1) (define b 2)")
+				result = @parser.read_from(tokens)
+				assert_equal([[:define, :a, 1], [:define, :b, 2]], result)
+			end
+			
+			should "be able to handle nested expressions" do
+				tokens = @parser.tokenize("(+ 2 (+ 3 5))")
+				result = @parser.read_from(tokens)
+				assert_equal([[:+, 2, [:+, 3, 5]]], result)
+			end
+		end
+		
+		context "to_string" do
+			should "turn a parsed statement back into a human readable format" do
+				result = @parser.to_string([:define, :a, 1])
+				assert_equal("(define a 1)", result)
+			end
+		end
+	end
+end

data/theta.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{theta}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Chris O'Neal"]
-  s.date = %q{2011-06-10}
+  s.date = %q{2011-06-20}
   s.description = %q{Theta was created as a learning project based off of lis.py and flea}
   s.email = %q{ctoneal@gmail.com}
   s.executables = ["theta", "theta"]
@@ -30,19 +30,37 @@ Gem::Specification.new do |s|
     "lib/theta/environment.rb",
     "lib/theta/interpreter.rb",
     "lib/theta/library/add.scm",
+    "lib/theta/library/display.scm",
     "lib/theta/library/divide.scm",
     "lib/theta/library/equality.scm",
     "lib/theta/library/greater_than.scm",
     "lib/theta/library/greater_than_or_equal.scm",
     "lib/theta/library/if.scm",
+    "lib/theta/library/input.scm",
     "lib/theta/library/lambda.scm",
     "lib/theta/library/less_than.scm",
     "lib/theta/library/less_than_or_equal.scm",
     "lib/theta/library/multiply.scm",
     "lib/theta/library/set.scm",
+    "lib/theta/library/string-to-num.scm",
     "lib/theta/library/subtract.scm",
     "lib/theta/parser.rb",
     "test/helper.rb",
+    "test/library/test_add.rb",
+    "test/library/test_divide.rb",
+    "test/library/test_equality.rb",
+    "test/library/test_greater_than.rb",
+    "test/library/test_greater_than_or_equal.rb",
+    "test/library/test_if.rb",
+    "test/library/test_lambda.rb",
+    "test/library/test_less_than.rb",
+    "test/library/test_less_than_or_equal.rb",
+    "test/library/test_multiply.rb",
+    "test/library/test_set.rb",
+    "test/library/test_subtract.rb",
+    "test/test_environment.rb",
+    "test/test_interpreter.rb",
+    "test/test_parser.rb",
     "theta.gemspec"
   ]
   s.homepage = %q{http://github.com/ctoneal/theta}
@@ -51,7 +69,22 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.6.2}
   s.summary = %q{Theta is a Lisp interpreter in Ruby}
   s.test_files = [
-    "test/helper.rb"
+    "test/helper.rb",
+    "test/library/test_add.rb",
+    "test/library/test_divide.rb",
+    "test/library/test_equality.rb",
+    "test/library/test_greater_than.rb",
+    "test/library/test_greater_than_or_equal.rb",
+    "test/library/test_if.rb",
+    "test/library/test_lambda.rb",
+    "test/library/test_less_than.rb",
+    "test/library/test_less_than_or_equal.rb",
+    "test/library/test_multiply.rb",
+    "test/library/test_set.rb",
+    "test/library/test_subtract.rb",
+    "test/test_environment.rb",
+    "test/test_interpreter.rb",
+    "test/test_parser.rb"
   ]
 
   if s.respond_to? :specification_version then

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: theta
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-10 00:00:00.000000000 -05:00
+date: 2011-06-20 00:00:00.000000000 -05:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &7339260 !ruby/object:Gem::Requirement
+  requirement: &2053176 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *7339260
+  version_requirements: *2053176
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &7338048 !ruby/object:Gem::Requirement
+  requirement: &2051736 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *7338048
+  version_requirements: *2051736
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &7336620 !ruby/object:Gem::Requirement
+  requirement: &2050476 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *7336620
+  version_requirements: *2050476
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &7334976 !ruby/object:Gem::Requirement
+  requirement: &2048832 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *7334976
+  version_requirements: *2048832
 description: Theta was created as a learning project based off of lis.py and flea
 email: ctoneal@gmail.com
 executables:
@@ -78,19 +78,37 @@ files:
 - lib/theta/environment.rb
 - lib/theta/interpreter.rb
 - lib/theta/library/add.scm
+- lib/theta/library/display.scm
 - lib/theta/library/divide.scm
 - lib/theta/library/equality.scm
 - lib/theta/library/greater_than.scm
 - lib/theta/library/greater_than_or_equal.scm
 - lib/theta/library/if.scm
+- lib/theta/library/input.scm
 - lib/theta/library/lambda.scm
 - lib/theta/library/less_than.scm
 - lib/theta/library/less_than_or_equal.scm
 - lib/theta/library/multiply.scm
 - lib/theta/library/set.scm
+- lib/theta/library/string-to-num.scm
 - lib/theta/library/subtract.scm
 - lib/theta/parser.rb
 - test/helper.rb
+- test/library/test_add.rb
+- test/library/test_divide.rb
+- test/library/test_equality.rb
+- test/library/test_greater_than.rb
+- test/library/test_greater_than_or_equal.rb
+- test/library/test_if.rb
+- test/library/test_lambda.rb
+- test/library/test_less_than.rb
+- test/library/test_less_than_or_equal.rb
+- test/library/test_multiply.rb
+- test/library/test_set.rb
+- test/library/test_subtract.rb
+- test/test_environment.rb
+- test/test_interpreter.rb
+- test/test_parser.rb
 - theta.gemspec
 has_rdoc: true
 homepage: http://github.com/ctoneal/theta
@@ -108,7 +126,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 260486451
+      hash: -440596785
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -123,3 +141,18 @@ specification_version: 3
 summary: Theta is a Lisp interpreter in Ruby
 test_files:
 - test/helper.rb
+- test/library/test_add.rb
+- test/library/test_divide.rb
+- test/library/test_equality.rb
+- test/library/test_greater_than.rb
+- test/library/test_greater_than_or_equal.rb
+- test/library/test_if.rb
+- test/library/test_lambda.rb
+- test/library/test_less_than.rb
+- test/library/test_less_than_or_equal.rb
+- test/library/test_multiply.rb
+- test/library/test_set.rb
+- test/library/test_subtract.rb
+- test/test_environment.rb
+- test/test_interpreter.rb
+- test/test_parser.rb