koi-reference-parser 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+*.gemspec
+*.swp

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Aaron Gough (http://thingsaaronmade.com/)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,44 @@
+= koi-reference-parser
+
+This is the reference parser implementation for the programming language {Koi}[http://github.com/aarongough/koi]. The parser is implemented using a {Parsing Expression Grammar (PEG)}[http://en.wikipedia.org/wiki/Parsing_expression_grammar] that is run by a PEG engine called {Treetop}[http://treetop.rubyforge.org/].
+
+=== Example
+
+The parser takes a text string containing a program like:
+
+  test = 1 + 2
+  
+And turns it into an {Abstract Syntax Tree (AST)}[http://en.wikipedia.org/wiki/Abstract_syntax_tree] that unambiguously represents the program's structure and meaning. The AST is represented as a series of Ruby objects that subclass a generic SyntaxNode class. The code above transformed into AST would look like:
+
+  <Block "test = 1 + 2">
+    <Statement "test = 1 + 2">
+      <Assignment "test = 1 + 2">
+        <Identifier "test">
+        <AssignmentOperator "=">
+        <Expression "1 + 2">
+          <AdditiveExpression "1 + 2">
+            <IntegerLiteral "1">
+            <AdditionOperator "+">
+            <IntegerLiteral "2">
+            
+
+=== Installation
+
+This parser is normally installed as part of Koi's default toolchain. However if you would like to install it on it's own you can do so by installing the gem like so:
+
+  gem install koi-reference-parser
+
+=== Usage
+
+  require 'rubygems'
+  require 'koi-reference-parser'
+  
+  include KoiReferenceParser
+  
+  ast = Parser.parse( program_text )
+
+=== Author & Credits
+
+Author:: {Aaron Gough}[mailto:aaron@aarongough.com]
+
+Copyright (c) 2010 {Aaron Gough}[http://thingsaaronmade.com/] ({thingsaaronmade.com}[http://thingsaaronmade.com/]), released under the MIT license

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "koi-reference-parser"
+    gemspec.summary = "A reference parser for the Koi language."
+    gemspec.description = "A reference parser for the Koi language."
+    gemspec.email = "aaron@aarongough.com"
+    gemspec.homepage = "http://github.com/aarongough/koi-reference-parser"
+    gemspec.authors = ["Aaron Gough"]
+    gemspec.rdoc_options << '--line-numbers' << '--inline-source'
+    gemspec.extra_rdoc_files = ['README.rdoc', 'MIT-LICENSE']
+    gemspec.add_dependency('treetop')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+
+desc 'Test koi-reference-parser.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib/*.rb'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+
+desc 'Generate documentation for koi-reference-parser.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'koi-reference-parser'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/**/*.rb')
+end

data/lib/koi-reference-parser.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+
+require_files = []
+require_files.concat Dir[File.join(File.dirname(__FILE__), 'parser', '**', '*.rb')]
+
+require_files.each do |file|
+  require File.expand_path(file)
+end

data/lib/parser/exceptions.rb

@@ -0,0 +1,2 @@
+class ParseError < Exception
+end

data/lib/parser/koi-reference-parser.treetop

@@ -0,0 +1,197 @@
+grammar KoiReferenceParser
+
+  rule block
+    statement+ <Block>
+  end
+
+  rule statement
+    space? ( hash_assignment / assignment / if / unless / function_call ) ';'? space? <Statement>
+  end
+  
+  rule nil
+    "nil" <NilLiteral>
+  end
+  
+  rule true
+    "true" <TrueLiteral>
+  end
+  
+  rule false
+    "false" <FalseLiteral>
+  end
+
+  rule integer
+    ('+' / '-')? [0-9]+ <IntegerLiteral>
+  end
+  
+  rule float
+    ('+' / '-')? [0-9]+ '.' [0-9]+ <FloatLiteral>
+  end
+  
+  rule string
+    '"' ([^"\\] / "\\" . )* '"' <StringLiteral>
+  end
+  
+  rule identifier
+    '$'? [a-zA-Z] [a-zA-Z0-9_]* <Identifier>
+  end
+  
+  rule hash_assignment
+    identifier hash_accessor_list space? assignment_operator space? ( hash / function_definition / expression ) <HashAssignment>
+  end
+  
+  rule assignment
+    identifier space? assignment_operator space? ( hash / function_definition / expression ) <Assignment>
+  end
+  
+  ##################
+  # Flow control
+  
+  rule if
+    'if(' space? expression space? ')' space
+      block
+    space? 'end' space? <If>
+  end
+  
+  rule unless
+    'unless(' space? expression space? ')' space
+      block
+    space? 'end' space? <Unless>
+  end
+  
+  ##################
+  # Functions
+  
+  rule function_call
+    identifier space? '(' space? expression? space? ','? expression? space? ')' <FunctionCall>
+  end
+  
+  rule function_definition
+    'function(' space? identifier space? ')' 
+      block
+    space? 'end' <FunctionDefinition>
+  end
+  
+  ##################
+  # Whitespace
+  
+  rule space
+    [\s]+ <Whitespace>
+  end
+  
+  ##################
+  # Hashes
+  
+  rule hash_accessor_list
+    hash_accessor+ <HashAccessorList>
+  end
+  
+  rule hash_accessor
+    '[' expression ']' <HashAccessor>
+  end
+  
+  rule hash
+    '{' key_value_list? '}' <HashLiteral>
+  end
+  
+  rule key_value_list
+    key_value+ <KeyValueList>
+  end
+  
+  rule key_value
+    space? expression space? '=>' space? expression space? ','? <KeyValue>
+  end
+  
+  rule key
+    space? expression space? <Key>
+  end
+  
+  rule value
+    space? expression space? <Value>
+  end
+
+  ##################
+  # Expressions
+  
+  rule expression
+    space? (hash_access / comparative / additive) <Expression>
+  end
+  
+  rule hash_access
+    identifier hash_accessor_list <HashAccess>
+  end
+  
+  rule comparative
+    additive space? (equality_operator / inequality_operator / greater_than_operator / less_than_operator) space? additive <ComparativeExpression>
+  end
+  
+  rule additive
+    multitive space? additive_operator space? additive <AdditiveExpression>
+    /
+    multitive 
+  end
+  
+  rule additive_operator
+    addition_operator 
+    /
+    subtraction_operator 
+  end
+
+  rule multitive
+    primary space? multitive_operator space? multitive <MultitiveExpression>
+    /
+    primary 
+  end
+  
+  rule multitive_operator
+    multiplication_operator 
+    /
+    division_operator  
+  end  
+  
+  rule primary
+    function_call / nil / false / true / identifier / float / integer / string 
+    /
+    '(' space? expression space? ')' <Expression>
+  end
+
+  ##################
+  # Operators
+
+  rule assignment_operator
+    '=' <AssignmentOperator>
+  end
+  
+  rule addition_operator
+    '+' <AdditionOperator>
+  end
+  
+  rule subtraction_operator
+    '-' <SubtractionOperator>
+  end
+  
+  rule multiplication_operator
+    '*' <MultiplicationOperator>
+  end
+  
+  rule division_operator
+    '/' <DivisionOperator>
+  end
+  
+  rule equality_operator
+    '==' <EqualityOperator>
+  end
+  
+  rule inequality_operator
+    '!=' <InequalityOperator>
+  end
+  
+  rule greater_than_operator
+    '>' <GreaterThanOperator>
+  end
+  
+  rule less_than_operator
+    '<' <LessThanOperator>
+  end
+
+end

data/lib/parser/parser.rb

@@ -0,0 +1,43 @@
+class Parser
+
+  require 'treetop'
+  Treetop.load(File.expand_path(File.join(File.dirname(__FILE__), 'koi-reference-parser.treetop')))
+  @@parser = KoiReferenceParserParser.new
+  
+  def self.parse(data)
+    tree = @@parser.parse(data)
+    
+    if(tree.nil?)
+      if( data.length > 80 )
+        error_detail = "\n\n" + data.slice(@@parser.index - 120, 80).gsub("\n", ";")
+        error_detail += "\n" + data.slice(@@parser.index - 40, 80).gsub("\n", ";")
+        error_detail += "\n" + " "*40 + "^\n"
+      else
+        error_detail = "\n\n" + data.gsub("\n", ";")
+        error_detail += "\n" + " " * @@parser.index + "^\n"
+      end
+      raise ParseError, "Parse error at index: #{@@parser.index}#{error_detail}"
+    end
+    
+    # clean up the tree by removing all nodes of default type 'SyntaxNode'
+    self.clean_tree(tree)
+    # clean up the tree further by removing all whitespace nodes
+    self.clean_whitespace(tree)
+    return tree
+  end
+  
+  private
+  
+    def self.clean_tree(root_node)
+      return if(root_node.elements.nil?)
+      root_node.elements.delete_if{|node| node.class.name == "Treetop::Runtime::SyntaxNode" }
+      root_node.elements.each {|node| self.clean_tree(node) }
+    end
+    
+    def self.clean_whitespace(root_node)
+      return if(root_node.elements.nil?)
+      root_node.elements.delete_if{|node| node.class.name == "KoiReferenceParser::Whitespace" }
+      root_node.elements.each {|node| self.clean_whitespace(node) }
+    end
+
+end

data/lib/parser/syntax_nodes.rb

@@ -0,0 +1,114 @@
+module KoiReferenceParser
+    
+    class Block < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Statement < Treetop::Runtime::SyntaxNode
+    end
+    
+    class HashAssignment < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Assignment < Treetop::Runtime::SyntaxNode
+    end
+    
+    class FunctionDefinition < Treetop::Runtime::SyntaxNode
+    end
+    
+    class If < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Unless < Treetop::Runtime::SyntaxNode
+    end
+    
+    class FunctionCall < Treetop::Runtime::SyntaxNode
+    end
+    
+    class NilLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class TrueLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class FalseLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class IntegerLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class FloatLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class StringLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class HashAccessorList < Treetop::Runtime::SyntaxNode
+    end
+    
+    class HashAccessor < Treetop::Runtime::SyntaxNode
+    end
+    
+    class HashLiteral < Treetop::Runtime::SyntaxNode
+    end
+    
+    class KeyValueList < Treetop::Runtime::SyntaxNode
+    end
+    
+    class KeyValue < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Key < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Value < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Identifier < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Whitespace < Treetop::Runtime::SyntaxNode
+    end
+    
+    class AssignmentOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class EqualityOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class InequalityOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class GreaterThanOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class LessThanOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class AdditionOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class SubtractionOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class MultiplicationOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class DivisionOperator < Treetop::Runtime::SyntaxNode
+    end
+    
+    class Expression < Treetop::Runtime::SyntaxNode
+    end
+    
+    class HashAccess < Treetop::Runtime::SyntaxNode
+    end
+    
+    class ComparativeExpression < Treetop::Runtime::SyntaxNode
+    end
+    
+    class AdditiveExpression < Treetop::Runtime::SyntaxNode
+    end
+    
+    class MultitiveExpression < Treetop::Runtime::SyntaxNode
+    end
+    
+end

data/test/parser/functional/function_call_as_argument.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class FunctionCallAsArgumentTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+  
+  test "should parse statement with function call as argument" do
+    assert_nothing_raised do
+      Parser.parse(<<-EOD)
+      
+        print( to_string( 1 ))
+        
+      EOD
+    end
+  end
+
+end

data/test/parser/functional/simple_program_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class SimpleProgramTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+  
+  test "should parse simple program with 'if' flow control" do
+    assert_nothing_raised do
+      Parser.parse(<<-EOD)
+      
+        test = 1
+      
+        if(test == 1)
+          test = "yay"
+        end
+        
+      EOD
+    end
+  end
+  
+  test "should parse simple program with 'unless' flow control" do
+    assert_nothing_raised do
+      Parser.parse(<<-EOD)
+      
+        test = 1
+      
+        unless(test == 1)
+          test = "yay"
+        end
+        
+      EOD
+    end
+  end
+
+end

data/test/parser/unit/assignment_test.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class AssignmentTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "assignment of integer" do
+    tree = Parser.parse('test = 1')
+    assert_assigns_expression(IntegerLiteral, '1', tree)
+  end
+  
+  test "assignment of explicitly positive integer" do
+    tree = Parser.parse('test = +1')
+    assert_assigns_expression(IntegerLiteral, '+1', tree)
+  end
+  
+  test "assignment of explicitly negative integer" do
+    tree = Parser.parse('test = -1')
+    assert_assigns_expression(IntegerLiteral, '-1', tree)
+  end
+  
+  test "assignment of float" do
+    tree = Parser.parse('test = 99.0009')
+    assert_assigns_expression(FloatLiteral, '99.0009', tree)
+  end
+  
+  test "assignment of explicitly positive float" do
+    tree = Parser.parse('test = +99.0009')
+    assert_assigns_expression(FloatLiteral, '+99.0009', tree)
+  end
+  
+  test "assignment of explicitly negative float" do
+    tree = Parser.parse('test = -99.0009')
+    assert_assigns_expression(FloatLiteral, '-99.0009', tree)
+  end
+  
+  test "assignment of string" do
+    tree = Parser.parse('test = "test_string"')
+    assert_assigns_expression(StringLiteral, '"test_string"', tree)
+  end
+  
+  test "assignment of string containing escaped quote" do
+    tree = Parser.parse('test = "test_\"string"')
+    assert_assigns_expression(StringLiteral, '"test_\"string"', tree)
+  end
+  
+  test "assignment of function definition" do
+    tree = Parser.parse('test = function(args) blah = 1 end')
+    assert_assigns(FunctionDefinition, nil, tree)
+  end
+  
+  test "assignment of result of function call" do
+    tree = Parser.parse('test = function(args)')
+    assert_assigns_expression(FunctionCall, nil, tree)
+  end
+  
+  test "assignment of nil" do
+    tree = Parser.parse('test = nil')
+    assert_assigns_expression(NilLiteral, nil, tree)
+  end
+  
+  test "assignment of boolean true" do
+    tree = Parser.parse('test = true')
+    assert_assigns_expression(TrueLiteral, nil, tree)
+  end
+  
+  test "assignment of boolean false" do
+    tree = Parser.parse('test = false')
+    assert_assigns_expression(FalseLiteral, nil, tree)
+  end
+  
+  test "assignment of empty hash literal" do
+    tree = Parser.parse('test = {}')
+    assert_assigns(HashLiteral, nil, tree)
+  end
+  
+  test "assignment of hash literal with single key-value pair" do
+    tree = Parser.parse('test = { 1 => 2 }')
+    assert_assigns(HashLiteral, nil, tree)
+  end
+  
+  test "assignment of hash literal with 2 key-value pairs" do
+    tree = Parser.parse('test = { 1 => 2, 2 => 2 }')
+    assert_assigns(HashLiteral, nil, tree)
+  end
+  
+  test "assignment of hash literal with 3 key-value pairs" do
+    tree = Parser.parse('test = { 1 => 2, 2 => 2, 3 => 2 }')
+    assert_assigns(HashLiteral, nil, tree)
+  end
+  
+  private
+  
+    def assert_assigns(node_type, value, tree)
+      assert_kind_of Block, tree
+      assert_kind_of Statement, tree.elements.last
+      assert_kind_of Assignment, tree.elements.last.elements.last
+      assert_kind_of Identifier, tree.elements.last.elements.last.elements[0]
+      assert_kind_of AssignmentOperator, tree.elements.last.elements.last.elements[1]
+      assert_kind_of node_type, tree.elements.last.elements.last.elements[2]
+      assert_equal value, tree.elements.last.elements.last.elements[2].text_value unless(value.nil?)
+    end
+    
+    def assert_assigns_expression(node_type, value, tree)
+      assert_kind_of Block, tree
+      assert_kind_of Statement, tree.elements.last
+      assert_kind_of Assignment, tree.elements.last.elements.last
+      assert_kind_of Identifier, tree.elements.last.elements.last.elements[0]
+      assert_kind_of AssignmentOperator, tree.elements.last.elements.last.elements[1]
+      assert_kind_of Expression, tree.elements.last.elements.last.elements[2]
+      assert_kind_of node_type, tree.elements.last.elements.last.elements[2].elements.first
+      assert_equal value, tree.elements.last.elements.last.elements[2].elements.first.text_value unless(value.nil?)
+    end
+
+end

data/test/parser/unit/compound_expression_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class SimpleExpressionTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "should parse expression that contains function call as value" do
+    tree = Parser.parse('test = blah(1) + 1')
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[2]
+    assert_kind_of AdditiveExpression, tree.elements.first.elements.last.elements[2].elements.first
+    assert_kind_of FunctionCall, tree.elements.first.elements.last.elements[2].elements.first.elements.first
+  end
+  
+  test "should parse expression that contains sub-expression as value" do
+    tree = Parser.parse('test = 2 * 3 * 2')
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[2]
+    assert_kind_of MultitiveExpression, tree.elements.first.elements.last.elements[2].elements.first
+    assert_kind_of IntegerLiteral, tree.elements.first.elements.last.elements[2].elements.first.elements[0]
+    assert_kind_of MultiplicationOperator, tree.elements.first.elements.last.elements[2].elements.first.elements[1]
+    assert_kind_of MultitiveExpression, tree.elements.first.elements.last.elements[2].elements.first.elements[2]
+  end
+  
+  test "should parse expression that contains parenthesized sub-expression as value" do
+    tree = Parser.parse('test = (2 * 3) * 2')
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[2]
+    assert_kind_of MultitiveExpression, tree.elements.first.elements.last.elements[2].elements.first
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[2].elements.first.elements[0]
+    assert_kind_of MultiplicationOperator, tree.elements.first.elements.last.elements[2].elements.first.elements[1]
+    assert_kind_of IntegerLiteral, tree.elements.first.elements.last.elements[2].elements.first.elements[2]
+  end
+
+end

data/test/parser/unit/function_call_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class FunctionCallTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "should parse function call with no arguments" do
+    tree = Parser.parse('test()')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of FunctionCall, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements.first
+  end
+  
+  test "should parse function call with identifier as argument" do
+    tree = Parser.parse('test(blah)')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of FunctionCall, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements[0]
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[1]
+  end
+  
+  test "should parse function call with multiple arguments" do
+    tree = Parser.parse('test(blah, blah2)')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of FunctionCall, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements[0]
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[1]
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[2]
+  end
+  
+  test "should parse function call with expression as argument" do
+    tree = Parser.parse('test(1 * 2)')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of FunctionCall, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements[0]
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[1]
+  end
+  
+  test "should parse function call with function call as argument" do
+    tree = Parser.parse('test( call())')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of FunctionCall, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements[0]
+    assert_kind_of Expression, tree.elements.first.elements.last.elements[1]
+  end
+
+end

data/test/parser/unit/function_definition_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class FunctionDefinitionTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "should parse function definition including it's statements" do
+    tree = Parser.parse("test = function(args)\n  teest1 = 1\n  test2 = 2\nend")
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.first
+    assert_kind_of FunctionDefinition, tree.elements.first.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.first.elements.last.elements.first
+    assert_kind_of Block, tree.elements.first.elements.first.elements.last.elements.last
+    assert_kind_of Statement, tree.elements.first.elements.first.elements.last.elements.last.elements[0]
+    assert_kind_of Statement, tree.elements.first.elements.first.elements.last.elements.last.elements[1]
+  end
+
+end

data/test/parser/unit/hash_accessor_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class HashAccessorTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "assignment to hash key" do
+    tree = Parser.parse('test[1] = 1')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of HashAssignment, tree.elements.first.elements.first
+    assert_kind_of Identifier, tree.elements.first.elements.first.elements.first
+    assert_kind_of HashAccessorList, tree.elements.first.elements.first.elements[1]
+    assert_kind_of HashAccessor, tree.elements.first.elements.first.elements[1].elements.first
+    assert_equal 1, tree.elements.first.elements.first.elements[1].elements.length
+  end
+  
+  test "assignment to a chain of hash key" do
+    tree = Parser.parse('test[1][2][3] = 1')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of HashAssignment, tree.elements.first.elements.first
+    assert_kind_of Identifier, tree.elements.first.elements.first.elements.first
+    assert_kind_of HashAccessorList, tree.elements.first.elements.first.elements[1]
+    assert_kind_of HashAccessor, tree.elements.first.elements.first.elements[1].elements.first
+    assert_equal 3, tree.elements.first.elements.first.elements[1].elements.length
+  end
+  
+  test "assignment of hash key" do
+    tree = Parser.parse('test = test[1]')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.first
+    assert_kind_of Identifier, tree.elements.first.elements.first.elements[0]
+    assert_kind_of Expression, tree.elements.first.elements.first.elements[2]
+    assert_kind_of HashAccess, tree.elements.first.elements.first.elements[2].elements.first
+    assert_kind_of Identifier, tree.elements.first.elements.first.elements[2].elements.first.elements[0]
+    assert_kind_of HashAccessorList, tree.elements.first.elements.first.elements[2].elements.first.elements[1]
+  end
+
+end

data/test/parser/unit/identifier_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class FunctionCallTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "should parse all lowercase identifier" do
+    tree = Parser.parse('test = "test"')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements.first
+  end
+
+  test "should parse identifier with trailing numeral" do
+    tree = Parser.parse('test1 = "test"')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements.first
+  end
+  
+  test "should parse identifier with leading capital letter" do
+    tree = Parser.parse('Test = "test"')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements.first
+  end
+  
+  test "should parse identifier that contains an underscore" do
+    tree = Parser.parse('test_test = "test"')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements.first
+  end
+  
+  test "should parse single character identifier" do
+    tree = Parser.parse('x = "test"')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements.first
+  end
+  
+  test "should parse identifier with leading $" do
+    tree = Parser.parse('$test = "test"')
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Assignment, tree.elements.first.elements.last
+    assert_kind_of Identifier, tree.elements.first.elements.last.elements.first
+  end
+
+end

data/test/parser/unit/if_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class IfTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "should parse if statement" do
+    tree = Parser.parse("if(1 == 1)\n test = 1\nend")
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of If, tree.elements.first.elements.first
+    assert_kind_of Expression, tree.elements.first.elements.first.elements.first
+    assert_kind_of Block, tree.elements.first.elements.first.elements.last
+  end
+  
+  test "should parse single line if statement" do
+    tree = Parser.parse("if(1 == 1) test = 1; end")
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of If, tree.elements.first.elements.first
+    assert_kind_of Expression, tree.elements.first.elements.first.elements.first
+    assert_kind_of Block, tree.elements.first.elements.first.elements.last
+  end
+
+end

data/test/parser/unit/simple_expression_test.rb

@@ -0,0 +1,212 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class SimpleExpressionTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  ###############
+  # ADDITION
+
+  test "should parse simple addition expression with integers" do
+    tree = Parser.parse('test = 1 + 1')
+    assert_expression(tree, AdditionOperator)
+  end
+  
+  test "should parse simple addition expression with floats" do
+    tree = Parser.parse('test = 1.0 + 1.0')
+    assert_expression(tree, AdditionOperator)
+  end
+  
+  test "should parse simple addition expression with strings" do
+    tree = Parser.parse('test = "1" + "1"')
+    assert_expression(tree, AdditionOperator)
+  end
+  
+  test "should parse simple addition expression with identifiers" do
+    tree = Parser.parse('test = test1 + test2')
+    assert_expression(tree, AdditionOperator)
+  end
+  
+  
+  ###############
+  # SUBTRACTION
+  
+  test "should parse simple subtraction expression with integers" do
+    tree = Parser.parse('test = 1 - 1')
+    assert_expression(tree, SubtractionOperator)
+  end
+  
+  test "should parse simple subtraction expression with floats" do
+    tree = Parser.parse('test = 1.0 - 1.0')
+    assert_expression(tree, SubtractionOperator)
+  end
+  
+  test "should parse simple subtraction expression with strings" do
+    tree = Parser.parse('test = "1" - "1"')
+    assert_expression(tree, SubtractionOperator)
+  end
+  
+  test "should parse simple subtraction expression with identifiers" do
+    tree = Parser.parse('test = test1 - test2')
+    assert_expression(tree, SubtractionOperator)
+  end
+  
+  
+  ###############
+  # MULTIPLICATION
+  
+  test "should parse simple multiplication expression with integers" do
+    tree = Parser.parse('test = 1 * 1')
+    assert_expression(tree, MultiplicationOperator)
+  end
+  
+  test "should parse simple multiplication expression with floats" do
+    tree = Parser.parse('test = 1.0 * 1.0')
+    assert_expression(tree, MultiplicationOperator)
+  end
+  
+  test "should parse simple multiplication expression with strings" do
+    tree = Parser.parse('test = "1" * "1"')
+    assert_expression(tree, MultiplicationOperator)
+  end
+  
+  test "should parse simple multiplication expression with identifiers" do
+    tree = Parser.parse('test = test1 * test2')
+    assert_expression(tree, MultiplicationOperator)
+  end
+  
+  
+  ###############
+  # DIVISION
+  
+  test "should parse simple division expression with integers" do
+    tree = Parser.parse('test = 1 / 1')
+    assert_expression(tree, DivisionOperator)
+  end
+  
+  test "should parse simple division expression with floats" do
+    tree = Parser.parse('test = 1.0 / 1.0')
+    assert_expression(tree, DivisionOperator)
+  end
+  
+  test "should parse simple division expression with strings" do
+    tree = Parser.parse('test = "1" / "1"')
+    assert_expression(tree, DivisionOperator)
+  end
+  
+  test "should parse simple division expression with identifiers" do
+    tree = Parser.parse('test = test1 / test2')
+    assert_expression(tree, DivisionOperator)
+  end
+  
+  
+  ###############
+  # EQUALITY
+  
+  test "should parse simple equality expression with integers" do
+    tree = Parser.parse('test = 1 == 1')
+    assert_expression(tree, EqualityOperator)
+  end
+  
+  test "should parse simple equality expression with floats" do
+    tree = Parser.parse('test = 1.0 == 1.0')
+    assert_expression(tree, EqualityOperator)
+  end
+  
+  test "should parse simple equality expression with strings" do
+    tree = Parser.parse('test = "1" == "1"')
+    assert_expression(tree, EqualityOperator)
+  end
+  
+  test "should parse simple equality expression with identifiers" do
+    tree = Parser.parse('test = test1 == test2')
+    assert_expression(tree, EqualityOperator)
+  end
+  
+  
+  ###############
+  # INEQUALITY
+  
+  test "should parse simple inequality expression with integers" do
+    tree = Parser.parse('test = 1 != 1')
+    assert_expression(tree, InequalityOperator)
+  end
+  
+  test "should parse simple inequality expression with floats" do
+    tree = Parser.parse('test = 1.0 != 1.0')
+    assert_expression(tree, InequalityOperator)
+  end
+  
+  test "should parse simple inequality expression with strings" do
+    tree = Parser.parse('test = "1" != "1"')
+    assert_expression(tree, InequalityOperator)
+  end
+  
+  test "should parse simple inequality expression with identifiers" do
+    tree = Parser.parse('test = test1 != test2')
+    assert_expression(tree, InequalityOperator)
+  end
+  
+  
+  ###############
+  # GREATER THAN
+  
+  test "should parse simple 'greater than' expression with integers" do
+    tree = Parser.parse('test = 1 > 1')
+    assert_expression(tree, GreaterThanOperator)
+  end
+  
+  test "should parse simple 'greater than' expression with floats" do
+    tree = Parser.parse('test = 1.0 > 1.0')
+    assert_expression(tree, GreaterThanOperator)
+  end
+  
+  test "should parse simple 'greater than' expression with strings" do
+    tree = Parser.parse('test = "1" > "1"')
+    assert_expression(tree, GreaterThanOperator)
+  end
+  
+  test "should parse simple 'greater than' expression with identifiers" do
+    tree = Parser.parse('test = test1 > test2')
+    assert_expression(tree, GreaterThanOperator)
+  end
+  
+  
+  ###############
+  # LESS THAN
+  
+  test "should parse simple 'less than' expression with integers" do
+    tree = Parser.parse('test = 1 < 1')
+    assert_expression(tree, LessThanOperator)
+  end
+  
+  test "should parse simple 'less than' expression with floats" do
+    tree = Parser.parse('test = 1.0 < 1.0')
+    assert_expression(tree, LessThanOperator)
+  end
+  
+  test "should parse simple 'less than' expression with strings" do
+    tree = Parser.parse('test = "1" < "1"')
+    assert_expression(tree, LessThanOperator)
+  end
+  
+  test "should parse simple 'less than' expression with identifiers" do
+    tree = Parser.parse('test = test1 < test2')
+    assert_expression(tree, LessThanOperator)
+  end
+  
+  
+  private
+  
+    def assert_expression(tree, operator = nil)
+      assert_kind_of Block, tree
+      assert_kind_of Statement, tree.elements.first
+      assert_kind_of Assignment, tree.elements.first.elements.last
+      assert_kind_of Identifier, tree.elements.first.elements.last.elements[0]
+      assert_kind_of AssignmentOperator, tree.elements.first.elements.last.elements[1]
+      assert_kind_of Expression, tree.elements.first.elements.last.elements[2]
+      assert_equal 3, tree.elements.first.elements.last.elements[2].elements.first.elements.size
+      assert_kind_of operator, tree.elements.first.elements.last.elements[2].elements.first.elements[1] unless(operator.nil?)
+    end
+
+end

data/test/parser/unit/statement_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class StatementTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "should parse statments on separate lines as separate" do
+    tree = Parser.parse("test = 1\ntest = 1")
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements[0]
+    assert_kind_of Statement, tree.elements[1]
+  end
+  
+  test "should parse statements on same line separated by ';' as separate" do
+    tree = Parser.parse("test = 1;test = 1")
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements[0]
+    assert_kind_of Statement, tree.elements[1]
+  end
+  
+
+end

data/test/parser/unit/unless_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper.rb'))
+
+class UnlessTest < Test::Unit::TestCase
+
+  include KoiReferenceParser
+
+  test "should parse unless statement" do
+    tree = Parser.parse("unless(1 == 1)\n test = 1\nend")
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Unless, tree.elements.first.elements.first
+    assert_kind_of Expression, tree.elements.first.elements.first.elements.first
+    assert_kind_of Block, tree.elements.first.elements.first.elements.last
+  end
+  
+  test "should parse single line unless statement" do
+    tree = Parser.parse("unless(1 == 1) test = 1; end")
+    assert_kind_of Block, tree
+    assert_kind_of Statement, tree.elements.first
+    assert_kind_of Unless, tree.elements.first.elements.first
+    assert_kind_of Expression, tree.elements.first.elements.first.elements.first
+    assert_kind_of Block, tree.elements.first.elements.first.elements.last
+  end
+
+end

data/test/setup/test_unit_extensions.rb

@@ -0,0 +1,21 @@
+module Test::Unit
+  # Used to fix a minor minitest/unit incompatibility in flexmock
+  AssertionFailedError = Class.new(StandardError)
+  
+  class TestCase
+   
+    def self.test(name, &block)
+      test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+      defined = instance_method(test_name) rescue false
+      raise "#{test_name} is already defined in #{self}" if defined
+      if block_given?
+        define_method(test_name, &block)
+      else
+        define_method(test_name) do
+          flunk "No implementation provided for #{name}"
+        end
+      end
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+
+require_files = []
+require_files << File.join(File.dirname(__FILE__), '..', 'lib', 'koi-reference-parser.rb')
+require_files.concat Dir[File.join(File.dirname(__FILE__), 'setup', '*.rb')]
+
+require_files.each do |file|
+  require File.expand_path(file)
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: koi-reference-parser
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Aaron Gough
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-30 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A reference parser for the Koi language.
+email: aaron@aarongough.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/koi-reference-parser.rb
+- lib/parser/exceptions.rb
+- lib/parser/koi-reference-parser.treetop
+- lib/parser/parser.rb
+- lib/parser/syntax_nodes.rb
+- test/parser/functional/function_call_as_argument.rb
+- test/parser/functional/simple_program_test.rb
+- test/parser/unit/assignment_test.rb
+- test/parser/unit/compound_expression_test.rb
+- test/parser/unit/function_call_test.rb
+- test/parser/unit/function_definition_test.rb
+- test/parser/unit/hash_accessor_test.rb
+- test/parser/unit/identifier_test.rb
+- test/parser/unit/if_test.rb
+- test/parser/unit/simple_expression_test.rb
+- test/parser/unit/statement_test.rb
+- test/parser/unit/unless_test.rb
+- test/setup/test_unit_extensions.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/aarongough/koi-reference-parser
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A reference parser for the Koi language.
+test_files: 
+- test/parser/functional/function_call_as_argument.rb
+- test/parser/functional/simple_program_test.rb
+- test/parser/unit/assignment_test.rb
+- test/parser/unit/compound_expression_test.rb
+- test/parser/unit/function_call_test.rb
+- test/parser/unit/function_definition_test.rb
+- test/parser/unit/hash_accessor_test.rb
+- test/parser/unit/identifier_test.rb
+- test/parser/unit/if_test.rb
+- test/parser/unit/simple_expression_test.rb
+- test/parser/unit/statement_test.rb
+- test/parser/unit/unless_test.rb
+- test/setup/test_unit_extensions.rb
+- test/test_helper.rb