koi-reference-parser 0.0.2 → 0.0.3

data/test/parser/unit/assignment_test.rb

@@ -1,115 +0,0 @@
-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/identifier_test.rb

@@ -1,55 +0,0 @@
-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/simple_expression_test.rb

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