RubyGems - koi-reference-parser - Versions diffs - 0.0.1 → 0.0.2 - Mend

koi-reference-parser 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

data/.gitignore +3 -3
data/MIT-LICENSE +19 -19
data/README.rdoc +43 -43
data/Rakefile +42 -42
data/VERSION +1 -0
data/lib/koi-reference-parser.rb +8 -8
data/lib/parser/exceptions.rb +1 -1
data/lib/parser/koi-reference-parser.treetop +197 -197
data/lib/parser/parser.rb +42 -42
data/lib/parser/syntax_node_extensions.rb +20 -0
data/lib/parser/syntax_nodes.rb +113 -113
data/test/parser/functional/function_call_as_argument.rb +16 -16
data/test/parser/functional/simple_program_test.rb +34 -34
data/test/parser/unit/assignment_test.rb +114 -114
data/test/parser/unit/compound_expression_test.rb +34 -34
data/test/parser/unit/function_call_test.rb +51 -51
data/test/parser/unit/function_definition_test.rb +18 -18
data/test/parser/unit/hash_accessor_test.rb +40 -40
data/test/parser/unit/identifier_test.rb +54 -54
data/test/parser/unit/if_test.rb +24 -24
data/test/parser/unit/simple_expression_test.rb +211 -211
data/test/parser/unit/statement_test.rb +21 -21
data/test/parser/unit/syntax_node_to_hash_test.rb +43 -0
data/test/parser/unit/unless_test.rb +24 -24
data/test/setup/test_unit_extensions.rb +20 -20
data/test/test_helper.rb +9 -9
metadata +11 -4

data/test/parser/unit/simple_expression_test.rb CHANGED

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

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