koi-reference-parser 0.0.1 → 0.0.2

data/lib/parser/parser.rb

@@ -1,43 +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
-
+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_node_extensions.rb

@@ -0,0 +1,20 @@
+module KoiReferenceParser
+
+  class Treetop::Runtime::SyntaxNode
+  
+    def to_hash()
+      hash = {}
+      hash[:offset] = self.interval.first
+      hash[:text_value] = self.text_value
+      hash[:name] = self.class.name.split("::").last
+      unless( self.elements.nil? )
+        hash[:elements] = self.elements.map {|element| element.to_hash() }
+      else
+        hash[:elements] = nil
+      end
+      return hash
+    end
+  
+  end
+
+end

data/lib/parser/syntax_nodes.rb

@@ -1,114 +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
-    
+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

@@ -1,17 +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
-
+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

@@ -1,35 +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
-
+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

@@ -1,115 +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
-
+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