kuniri 0.0.1 → 0.2

data/spec/language/ruby/global_test/repetition/very_nested_repetition_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../../../../spec_helper'
+
+RSpec.describe "Verify repetition output with a nested conditional" do
+
+  before :each do
+    @path = "./spec/language/ruby/global_test/repetition/.kuniri6.yml"
+    @kuniri = Kuniri::Kuniri.new
+    @kuniri.read_configuration_file(@path)
+    @kuniri.run_analysis
+    parser = Parser::XMLOutputFormat.new(@kuniri.configurationInfo[:output])
+    parser.create_all_data(@kuniri.get_parser())
+    @output = File.open("./spec/language/ruby/global_test/repetition/veryNestedRepetition.xml", "r")
+  end
+
+  RSpec.shared_examples "Nested multiple verification" do |regex, description|
+
+    it "Global Function: #{description}" do
+      repetition = nil
+      @output.each do |line|
+        repetition = line =~ regex
+        break unless repetition.nil?
+      end
+      expect(repetition).not_to be_nil
+    end
+
+  end
+
+  context "Test neted repetition" do
+
+    message = "Global Function: for level0 in 0..5"
+    regex = /\s+<for\sexpression="level0 in 0\.\.5"\slevel="0"\/?>/
+    include_examples "Nested multiple verification" , regex, message
+
+    message = "Global Function: for level1 in 0..6"
+    regex = /\s+<for\sexpression="level1 in 0\.\.6"\slevel="1"\/?>/
+    include_examples "Nested multiple verification" , regex, message
+
+    message = "Global Function: for level2 in 0..7"
+    regex = /\s+<for\sexpression="level2 in 0\.\.7"\slevel="2"\/?>/
+    include_examples "Nested multiple verification" , regex, message
+
+    message = "Global Function: for level3 in 0..8"
+    regex = /\s+<for\sexpression="level3 in 0\.\.8"\slevel="3"\/?>/
+    include_examples "Nested multiple verification" , regex, message
+
+    message = "Global Function: for level4 in 0..9"
+    regex = /\s+<for\sexpression="level4 in 0\.\.9"\slevel="4"\/?>/
+    include_examples "Nested multiple verification" , regex, message
+
+    message = "Global Function: for level5 in 0..10"
+    regex = /\s+<for\sexpression="level5 in 0\.\.10"\slevel="5"\/?>/
+    include_examples "Nested multiple verification" , regex, message
+
+    message = "Global Function: for level6 in 0..11"
+    regex = /\s+<for\sexpression="level6 in 0\.\.11"\slevel="6"\/?>/
+    include_examples "Nested multiple verification" , regex, message
+
+  end
+
+  after :each do
+    @kuniri = nil
+    @output = nil
+  end
+
+end

data/spec/language/ruby/method_ruby_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::MethodRuby do
+
+  before :all do
+    @methodRuby = Languages::Ruby::MethodRuby.new
+  end
+
+  context "When method without parameter" do
+    it "Simple declaration" do
+      input = "def xpto"
+      expect(@methodRuby.get_method(input).name)
+             .to eq("xpto")
+    end
+
+    it "With spaces in the begin" do
+      input = "         def xpto"
+      expect(@methodRuby.get_method(input).name)
+             .to eq("xpto")
+    end
+
+    it "With spaces in the begin and between method name" do
+      input = "        def     xpto"
+      expect(@methodRuby.get_method(input).name)
+             .to eq("xpto")
+      input = "                 def             xpto"
+      expect(@methodRuby.get_method(input).name)
+             .to eq("xpto")
+    end
+
+    it "With spaces in the end" do
+      input = "def xpto                   "
+      expect(@methodRuby.get_method(input).name)
+             .to eq("xpto")
+      input = "def              xpto                   "
+      expect(@methodRuby.get_method(input).name)
+             .to eq("xpto")
+    end
+
+    it "With spaces in both sides" do
+      input = "           def             xpto              "
+      expect(@methodRuby.get_method(input).name)
+             .to eq("xpto")
+    end
+
+  end
+
+  after :all do
+    @constructor = nil
+  end
+
+end 

data/spec/language/ruby/repetition_ruby_spec.rb

@@ -6,24 +6,191 @@ RSpec.describe Languages::Ruby::RepetitionRuby do
     @repetitionRuby = Languages::Ruby::RepetitionRuby.new
   end
 
-  context "When it is if statment." do
-    it "Simple if statment." do
+  context "While loop" do
+    it "Simple while statement." do
       input = "while gets do"
-      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
-      expect(repetitionCaptured).to eq("gets")
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.expression).to eq("gets")
+      expect(repetitionCaptured.type).to eq(Languages::WHILE_LABEL)
+    end
 
+    it "Numerical statement" do
       input = "while 2 < 3 do"
       repetitionCaptured = @repetitionRuby.get_repetition(input).expression
       expect(repetitionCaptured).to eq("2 < 3")
+    end
 
-      #input = "for x.range(0,1)"
-      #repetitionCaptured = @repetitionRuby.get_repetition(input).expression
-      #expect(repetitionCaptured).to eq("x.range(0,1)")
-
+    it "Big number" do
       input = "while x == 222222 do"
       repetitionCaptured = @repetitionRuby.get_repetition(input).expression
       expect(repetitionCaptured).to eq("x == 222222")
     end
+
+    it "Compare with string" do
+      input = 'while x == "abc" do'
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq('x == "abc"')
+    end
+
+    it "While with multiple spaces between expression" do
+      input = 'while                                x == "abc" do'
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq('x == "abc"')
+    end
+
+    it "While with multiple spaces in the beginning" do
+      input = '         while x == "abc" do'
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.expression).to eq('x == "abc"')
+      expect(repetitionCaptured.type).to eq(Languages::WHILE_LABEL)
+    end
+
+    it "'Do' is not mandatory" do
+      input = "while x > 3"
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.type).to eq(Languages::WHILE_LABEL)
+    end
+
+    it "Not match" do
+      input = "whiles x > 3"
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured).to eq(nil)
+    end
+
+  end
+
+  context "For loop" do
+    it "Simple for statement." do
+      input = "for i in 0..5"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq("i in 0..5")
+    end
+
+    it "Multiple spaces in the beginning of for" do
+      input = "              for i in 0..5"
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.expression).to eq("i in 0..5")
+      expect(repetitionCaptured.type).to eq(Languages::FOR_LABEL)
+    end
+
+    it "Multiple spaces between of for and expression" do
+      input = "              for      i in 0..5"
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.expression).to eq("i in 0..5")
+      expect(repetitionCaptured.type).to eq(Languages::FOR_LABEL)
+    end
+
+    it "No match" do
+      input = "for xpto"
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured).to eq(nil)
+    end
+
+    it "We can have 'do' or not at the end" do
+      input = "for i in 0..5 do"
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.expression).to eq("i in 0..5")
+    end
+
+    it "For with 'do' and space in the end" do
+      input = "for i in 0..5 do              "
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.expression).to eq("i in 0..5")
+    end
+
+  end
+
+  context "Until loop" do
+    it "Simple until statement" do
+      input = "until $i > $num  do"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq("$i > $num")
+    end
+
+    it "Compare with string" do
+      input = 'until xpto == "exit" do'
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq('xpto == "exit"')
+    end
+
+    it "Check correct type" do
+      input = 'until xpto == "exit" do'
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.type).to eq(Languages::UNTIL_LABEL)
+    end
+
+    it "'Do' is not mandatory with until" do
+      input = 'until xpto == "exit"'
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.type).to eq(Languages::UNTIL_LABEL)
+    end
+
+    it "Until without 'do' and with space at the end" do
+      input = 'until xpto == "exit"                                  '
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.type).to eq(Languages::UNTIL_LABEL)
+    end
+
+    it "Until without 'do' and with space at the begin and the end" do
+      input = '    until xpto == "exit"                                  '
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured.type).to eq(Languages::UNTIL_LABEL)
+    end
+
+    it "Not match" do
+      input = 'untils xpto == "exit"'
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured).to eq(nil)
+    end
+
+  end
+
+  context "Do while" do
+    it "Simple do while statement" do
+      input = "end while $i < $num"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq("$i < $num")
+    end
+
+    it "No match" do
+      input = "end whiles $xpto > 23 do"
+      repetitionCaptured = @repetitionRuby.get_repetition(input)
+      expect(repetitionCaptured).to eq(nil)
+    end
+
+   # it "No match" do
+   #   input = "end while $xpto > 23 do"
+   #   repetitionCaptured = @repetitionRuby.get_repetition(input)
+   #   expect(repetitionCaptured).to eq(nil)
+   # end
+
+  end
+
+  context "Iterators loop" do
+    it "Simple each iterator" do
+      input = "abc.each do |something|"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).type
+      expect(repetitionCaptured).to eq("EACH")
+    end
+
+    it "Simple each_with_index iterator" do
+      input = "abc.each_with_index do |something|"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).type
+      expect(repetitionCaptured).to eq("EACH_WITH_INDEX")
+    end
+
+    it "Simple collect iterator" do
+      input = "abc.collect do |something|"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).type
+      expect(repetitionCaptured).to eq("COLLECT")
+    end
+
+    it "Simple collect iterator" do
+      input = "abc.map do |something|"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).type
+      expect(repetitionCaptured).to eq("MAP")
+    end
+
   end
 
   after :each do

data/spec/language/ruby/ruby_syntax_spec.rb

@@ -4,6 +4,8 @@ RSpec.describe Languages::RubySyntax do
 
   before :each do
     @syntax = Languages::RubySyntax.new
+    @syntax.metadata.allClasses.clear
+    @syntax.metadata.allAggregations.clear
   end
 
   context "Extern requirement detections." do
@@ -24,15 +26,15 @@ RSpec.describe Languages::RubySyntax do
       path = "spec/samples/rubySyntaxParts/extern/requireRelative.rb"
 
       @syntax.analyse_source(path)
-      expect(@syntax.fileElements[0].extern_requirements[0].name).to eq ("one")
-      expect(@syntax.fileElements[0].extern_requirements[1].name).to eq ("two")
-      expect(@syntax.fileElements[0].extern_requirements[2].name)
+      expect(@syntax.fileElements[0].extern_requirements[0].library).to eq ("one")
+      expect(@syntax.fileElements[0].extern_requirements[1].library).to eq ("two")
+      expect(@syntax.fileElements[0].extern_requirements[2].library)
         .to eq ("three")
-      expect(@syntax.fileElements[0].extern_requirements[3].name)
+      expect(@syntax.fileElements[0].extern_requirements[3].library)
         .to eq ("four")
-      expect(@syntax.fileElements[0].extern_requirements[4].name)
+      expect(@syntax.fileElements[0].extern_requirements[4].library)
         .to eq ("five")
-      expect(@syntax.fileElements[0].extern_requirements[5].name).to eq ("six")
+      expect(@syntax.fileElements[0].extern_requirements[5].library).to eq ("six")
       expect(@syntax.fileElements[0].extern_requirements.size).to eq (6)
     end
 
@@ -50,20 +52,20 @@ RSpec.describe Languages::RubySyntax do
       path = "spec/samples/rubySyntaxParts/extern/simpleExternRequirement.rb"
 
       @syntax.analyse_source(path)
-      expect(@syntax.fileElements[0].extern_requirements[0].name).to eq ("one")
-      expect(@syntax.fileElements[0].extern_requirements[1].name).to eq ("two")
-      expect(@syntax.fileElements[0].extern_requirements[2].name)
+      expect(@syntax.fileElements[0].extern_requirements[0].library).to eq ("one")
+      expect(@syntax.fileElements[0].extern_requirements[1].library).to eq ("two")
+      expect(@syntax.fileElements[0].extern_requirements[2].library)
         .to eq ("three")
-      expect(@syntax.fileElements[0].extern_requirements[3].name)
+      expect(@syntax.fileElements[0].extern_requirements[3].library)
         .to eq ("four")
-      expect(@syntax.fileElements[0].extern_requirements[4].name)
+      expect(@syntax.fileElements[0].extern_requirements[4].library)
         .to eq ("five")
-      expect(@syntax.fileElements[0].extern_requirements[5].name).to eq ("six")
-      expect(@syntax.fileElements[0].extern_requirements[6].name)
+      expect(@syntax.fileElements[0].extern_requirements[5].library).to eq ("six")
+      expect(@syntax.fileElements[0].extern_requirements[6].library)
         .to eq ("seven")
-      expect(@syntax.fileElements[0].extern_requirements[7].name)
+      expect(@syntax.fileElements[0].extern_requirements[7].library)
         .to eq ("eight")
-      expect(@syntax.fileElements[0].extern_requirements[8].name)
+      expect(@syntax.fileElements[0].extern_requirements[8].library)
         .to eq ("nine")
       expect(@syntax.fileElements[0].extern_requirements.size).to eq (9)
     end
@@ -171,6 +173,20 @@ RSpec.describe Languages::RubySyntax do
       expect(@syntax.fileElements[0].classes[4].name).to eq("Simple5")
     end
 
+    it "All classes in Metadata array" do
+      path = "spec/samples/rubySyntaxParts/class/simpleClass.rb"
+
+      @syntax.analyse_source(path)
+
+      expect(@syntax.metadata.allClasses.size).to eq(5)
+      expect(@syntax.metadata.allClasses[0].name).to eq('Simple1')
+      expect(@syntax.metadata.allClasses[1].name).to eq('Simple2')
+      expect(@syntax.metadata.allClasses[2].name).to eq('Simple3')
+      expect(@syntax.metadata.allClasses[3].name).to eq('Simple4')
+      expect(@syntax.metadata.allClasses[4].name).to eq('Simple5')
+    end
+
+
   end
 
   context "Attribute line" do
@@ -225,6 +241,10 @@ RSpec.describe Languages::RubySyntax do
         .to eq("method2")
       expect(@syntax.fileElements[0].classes[0].methods[2].name)
         .to eq("method3")
+      expect(@syntax.fileElements[0].classes[0].methods[3].name)
+        .to eq("method4")
+      expect(@syntax.fileElements[0].classes[0].methods[4].name)
+        .to eq("method5")
     end
   end
 
@@ -267,25 +287,20 @@ RSpec.describe Languages::RubySyntax do
         "spec/samples/rubySyntaxParts/conditionalStatment/simpleConditional.rb"
 
       @syntax.analyse_source(path)
-      expect(@syntax.fileElements[0].global_functions[0].name)
-        .to eq("simple1")
-
-      expect(@syntax.fileElements[0].global_functions[0]
-            .conditionals[0].expression).to eq("3 > 2")
-      expect(@syntax.fileElements[0].global_functions[0]
-            .conditionals[0].type).to eq("IF")
-
-      expect(@syntax.fileElements[0].global_functions[1].name)
-        .to eq("simple2")
-      expect(@syntax.fileElements[0].global_functions[1]
-            .conditionals[0].expression).to eq("7 > 2")
-      expect(@syntax.fileElements[0].global_functions[1]
-            .conditionals[0].type).to eq("IF")
-
-      expect(@syntax.fileElements[0].global_functions[1]
-            .conditionals[1].expression).to eq("\"a\" < \"k\"")
-      expect(@syntax.fileElements[0].global_functions[1]
-            .conditionals[1].type).to eq("IF")
+      allFuntion0 = @syntax.fileElements[0].global_functions[0]
+                                            .managerCondAndLoop.basicStructure
+      allFuntion1 = @syntax.fileElements[0].global_functions[1]
+                                            .managerCondAndLoop.basicStructure
+
+      expect(@syntax.fileElements[0].global_functions[0].name).to eq("simple1")
+      expect(allFuntion0[0].expression).to eq("3 > 2")
+      expect(allFuntion0[0].type).to eq(Languages::IF_LABEL)
+
+      expect(@syntax.fileElements[0].global_functions[1].name).to eq("simple2")
+      expect(allFuntion1[0].expression).to eq("7 > 2")
+      expect(allFuntion1[0].type).to eq(Languages::IF_LABEL)
+      expect(allFuntion1[1].expression).to eq("\"a\" < \"k\"")
+      expect(allFuntion1[1].type).to eq(Languages::IF_LABEL)
     end
 
     it "Correct state transition (Method)." do
@@ -304,40 +319,41 @@ RSpec.describe Languages::RubySyntax do
         "spec/samples/rubySyntaxParts/conditionalStatment/methodConditional.rb"
 
       @syntax.analyse_source(path)
+      allMethod0 = @syntax.fileElements[0].classes[0].methods[0]
+                                          .managerCondAndLoop.basicStructure
+      allMethod1 = @syntax.fileElements[0].classes[0].methods[1]
+                                          .managerCondAndLoop.basicStructure
+      allMethod2 = @syntax.fileElements[0].classes[0].methods[2]
+                                          .managerCondAndLoop.basicStructure
+      allMethod3 = @syntax.fileElements[0].classes[0].methods[3]
+                                          .managerCondAndLoop.basicStructure
+
       expect(@syntax.fileElements[0].classes[0].methods[0].name)
         .to eq("method1")
 
-      expect(@syntax.fileElements[0].classes[0].methods[0].conditionals[0]
-              .expression).to eq("x > 3")
-      expect(@syntax.fileElements[0].classes[0].methods[0].conditionals[0]
-              .type).to eq("IF")
+      expect(allMethod0[0].expression).to eq("x > 3")
+      expect(allMethod0[0].type).to eq(Languages::IF_LABEL)
 
       expect(@syntax.fileElements[0].classes[0].methods[1].name)
         .to eq("method2")
-      expect(@syntax.fileElements[0].classes[0].methods[1].conditionals[0]
-              .expression).to eq("b && c")
-      expect(@syntax.fileElements[0].classes[0].methods[1].conditionals[0]
-              .type).to eq("IF")
+      expect(allMethod1[0].expression).to eq("b && c")
+      expect(allMethod1[0].type).to eq(Languages::IF_LABEL)
 
       expect(@syntax.fileElements[0].classes[0].methods[2].name)
         .to eq("method3")
-      expect(@syntax.fileElements[0].classes[0].methods[2].conditionals[0]
-              .expression).to eq("b == 3")
-      expect(@syntax.fileElements[0].classes[0].methods[2].conditionals[1]
-              .expression).to eq("b < 7")
+      expect(allMethod2[0].expression).to eq("b == 3")
+      expect(allMethod2[1].expression).to eq("b < 7")
 
-      expect(@syntax.fileElements[0].classes[0].methods[2].conditionals[0]
-              .type).to eq("IF")
+      expect(allMethod2[0].type).to eq(Languages::IF_LABEL)
 
       expect(@syntax.fileElements[0].classes[0].methods[3].name)
         .to eq("method4")
-      expect(@syntax.fileElements[0].classes[0].methods[3].conditionals[0]
-              .expression).to eq("x")
+      expect(allMethod3[0].expression).to eq("x")
     end
 
     it "Correct state transition (Constructor)." do
-      path =
-        "spec/samples/rubySyntaxParts/conditionalStatment/constructorConditional.rb"
+      path = "spec/samples/rubySyntaxParts/" +
+              "conditionalStatment/constructorConditional.rb"
 
       expect(@syntax.state)
         .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
@@ -347,43 +363,46 @@ RSpec.describe Languages::RubySyntax do
     end
 
     it "Correct data capture (conditional - method)" do
-       path =
-        "spec/samples/rubySyntaxParts/conditionalStatment/constructorConditional.rb"
+       path = "spec/samples/rubySyntaxParts/" +
+                "conditionalStatment/constructorConditional.rb"
 
       @syntax.analyse_source(path)
+      allConstructor = @syntax.fileElements[0].classes[0].constructors[0]
+                                            .managerCondAndLoop.basicStructure
       expect(@syntax.fileElements[0].classes[0].constructors[0].name)
           .to eq("initialize")
 
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[0]
-              .expression).to eq("a > b")
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[0]
-              .type).to eq("IF")
+      expect(allConstructor[0].expression).to eq("a > b")
+      expect(allConstructor[0].type).to eq(Languages::IF_LABEL)
+
+      expect(allConstructor[1].expression).to eq("x")
+      expect(allConstructor[1].type).to eq(Languages::CASE_LABEL)
 
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[1]
-              .expression).to eq("x")
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[1]
-              .type).to eq("CASE")
+      expect(allConstructor[2].expression).to eq("3")
+      expect(allConstructor[2].type).to eq(Languages::WHEN_LABEL)
+      expect(allConstructor[3].expression).to eq("8")
+      expect(allConstructor[3].type).to eq(Languages::WHEN_LABEL)
+      expect(allConstructor[4].expression).to eq("90")
+      expect(allConstructor[4].type).to eq(Languages::WHEN_LABEL)
+      expect(allConstructor[5].type).to eq(Languages::ELSE_LABEL)
 
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[2]
-              .expression).to eq("u && y")
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[2]
-              .type).to eq("IF")
+      expect(allConstructor[6].expression).to eq("u && y")
+      expect(allConstructor[6].type).to eq(Languages::IF_LABEL)
 
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[3]
-              .expression).to eq("u == 1")
-      expect(@syntax.fileElements[0].classes[0].constructors[0].conditionals[3]
-              .type).to eq("ELSIF")
+      expect(allConstructor[7].expression).to eq("u == 1")
+      expect(allConstructor[7].type).to eq(Languages::ELSIF_LABEL)
     end
 
     it "Correct data capture (repetition[while] -  Method)" do
        path = "spec/samples/rubySyntaxParts/repetition/simpleRepetition.rb"
 
       @syntax.analyse_source(path)
-      expect(@syntax.fileElements[0].classes[0].methods[0].name)
-          .to eq("simple1")
+      allLoop = @syntax.fileElements[0].classes[0]
+                      .methods[0].managerCondAndLoop.basicStructure
 
-      expect(@syntax.fileElements[0].classes[0].methods[0].repetitions[0]
-              .expression).to eq("i < num")
+      expect(@syntax.fileElements[0].classes[0].methods[0].name)
+              .to eq("simple1")
+      expect(allLoop[0].expression).to eq("i < num")
     end
 
     it "Correct data capture (repetiton[util] - Method)" do
@@ -393,8 +412,9 @@ RSpec.describe Languages::RubySyntax do
       expect(@syntax.fileElements[0].classes[0].methods[1].name)
           .to eq("simple2")
 
-      expect(@syntax.fileElements[0].classes[0].methods[1].repetitions[0]
-              .expression).to eq("i > num")
+      all = @syntax.fileElements[0].classes[0].methods[1]
+                    .managerCondAndLoop.basicStructure
+      expect(all[0].expression).to eq("i > num")
 
     end
 
@@ -405,8 +425,9 @@ RSpec.describe Languages::RubySyntax do
       expect(@syntax.fileElements[0].classes[0].methods[1].name)
           .to eq("simple2")
 
-      expect(@syntax.fileElements[0].classes[0].methods[1].repetitions[1]
-              .expression).to eq("i in 0..5")
+      all = @syntax.fileElements[0].classes[0].methods[1]
+                    .managerCondAndLoop.basicStructure
+      expect(all[1].expression).to eq("i in 0..5")
     end
 
   end
@@ -415,7 +436,8 @@ RSpec.describe Languages::RubySyntax do
 
     it "Correct single line comment capture - Globals" do
 
-      path = "spec/samples/rubySyntaxParts/comment/simple_single_line_comment_global.rb"
+      path = "spec/samples/rubySyntaxParts/" +
+              "comment/simple_single_line_comment_global.rb"
 
       @syntax.analyse_source(path)
       expect(@syntax.fileElements[0].comments).to eq(" First comment\n")
@@ -429,7 +451,8 @@ RSpec.describe Languages::RubySyntax do
 
     it "Correct single line comment capture - Class" do
 
-      path = "spec/samples/rubySyntaxParts/comment/simple_single_line_comment_class.rb"
+      path = "spec/samples/rubySyntaxParts/" +
+              "comment/simple_single_line_comment_class.rb"
 
       @syntax.analyse_source(path)
       expect(@syntax.fileElements[0].classes[0].comments)
@@ -439,14 +462,16 @@ RSpec.describe Languages::RubySyntax do
       expect(@syntax.fileElements[0].classes[0].methods[0].comments)
               .to eq(" Comment 3: method\n")
       expect(@syntax.fileElements[0].classes[0].methods[1].comments)
-              .to eq(" Comment 4: Combo 1\n Comment 5: Combo 2\n")
+              .to eq(" Comment 4: Combo 1\n Comment 5: "+
+                      "Combo 2\n Comment 6: Combo 3; Combo 4\n")
       expect(@syntax.fileElements[0].classes[0].attributes[0].comments)
-              .to eq (" Comment 6: Attribute\n")
+              .to eq (" Comment 7: Attribute\n")
     end
 
     it "Correct multiple line comment capture - Global" do
 
-      path = "spec/samples/rubySyntaxParts/comment/simple_multiple_line_comment_global.rb"
+      path = "spec/samples/rubySyntaxParts/" +
+              "comment/simple_multiple_line_comment_global.rb"
 
       @syntax.analyse_source(path)
       expect(@syntax.fileElements[0].comments)
@@ -459,7 +484,8 @@ RSpec.describe Languages::RubySyntax do
 
     it "Correct multiple line comment capture - Class" do
 
-      path = "spec/samples/rubySyntaxParts/comment/simple_multiple_line_comment_class.rb"
+      path = "spec/samples/rubySyntaxParts/" +
+              "comment/simple_multiple_line_comment_class.rb"
 
       @syntax.analyse_source(path)
       expect(@syntax.fileElements[0].classes[0].comments)
@@ -470,7 +496,110 @@ RSpec.describe Languages::RubySyntax do
               .to eq("    First method\n")
       expect(@syntax.fileElements[0].classes[0].methods[1].comments)
               .to eq("    methodTwo\n")
+      expect(@syntax.fileElements[0].classes[0].methods[2].comments)
+              .to eq("    method;Three\n")
+
+    end
+
+  end
+
+  context "Aggregation" do
+
+    it "Aggregation single line capture in constructor" do
+      path = "spec/samples/rubySyntaxParts/" +
+              "aggregation/constructorAggregation.rb"
+
+      @syntax.analyse_source(path)
+
+      expect(@syntax.fileElements[0].classes[2].aggregations[0].name)
+        .to eq("Foo")
+      expect(@syntax.fileElements[0].classes[2].aggregations[1].name)
+        .to eq("Blah")
+    end
+
+    it "Aggregation single line capture in method" do
+      path = "spec/samples/rubySyntaxParts/" +
+              "aggregation/methodAggregation.rb"
+
+      @syntax.analyse_source(path)
+
+      expect(@syntax.fileElements[0].classes[2].aggregations[0].name)
+        .to eq("Test1")
+      expect(@syntax.fileElements[0].classes[2].aggregations[1].name)
+        .to eq("Test2")
+    end
+
+    it "Aggregation single line capture in class" do
+      path = "spec/samples/rubySyntaxParts/" +
+              "aggregation/classAggregation.rb"
+
+      @syntax.analyse_source(path)
+
+      expect(@syntax.fileElements[0].classes[2].aggregations[0].name)
+        .to eq("Class1")
+      expect(@syntax.fileElements[0].classes[2].aggregations[1].name)
+        .to eq("Class2")
+    end
+
+    it "All aggregations in Metadata array" do
+      path = "spec/samples/rubySyntaxParts/" +
+              "aggregation/classAggregation.rb"
+
+
+      @syntax.analyse_source(path)
+
+      expect(@syntax.metadata.allAggregations.size).to eq(2)
+      expect(@syntax.metadata.allAggregations[0].name).to eq('Class1')
+      expect(@syntax.metadata.allAggregations[1].name).to eq('Class2')
+
+    end
+
+  end
+
+  context 'Second parser' do
+
+    it 'All Classes should be sorted by name' do
+       path = "spec/samples/rubySyntaxParts/" +
+              "aggregation/multipleAggregation.rb"
+
+       @syntax.analyse_source(path)
+
+       expect(@syntax.metadata.allClasses.size).to eq(5)
+       expect(@syntax.metadata.allClasses[0].name).to eq('Class1')
+       expect(@syntax.metadata.allClasses[1].name).to eq('Class2')
+       expect(@syntax.metadata.allClasses[2].name).to eq('Class3')
+       expect(@syntax.metadata.allClasses[3].name).to eq('Class4')
+       expect(@syntax.metadata.allClasses[4].name).to eq('Class5')
+
+    end
+
+    it 'All Aggregation should be sorted by name and be unique' do
+      path = "spec/samples/rubySyntaxParts/" +
+              "aggregation/multipleAggregation.rb"
+
+      @syntax.analyse_source(path)
+
+      expect(@syntax.metadata.allAggregations.size).to eq(5)
+      expect(@syntax.metadata.allAggregations[0].name).to eq('Array')
+      expect(@syntax.metadata.allAggregations[1].name).to eq('Class1')
+      expect(@syntax.metadata.allAggregations[2].name).to eq('Class2')
+      expect(@syntax.metadata.allAggregations[3].name).to eq('Class3')
+      expect(@syntax.metadata.allAggregations[4].name).to eq('Set')
+    end
+
+    it 'Ruby default classes should not be present in Aggregation' do
+      path = "spec/samples/rubySyntaxParts/" +
+              "aggregation/multipleAggregation.rb"
+
+      @syntax.analyse_source(path)
 
+      expect(@syntax.fileElements[0].classes[4].aggregations.size).to eq(3)
+      expect(@syntax.fileElements[0].classes[4].aggregations[0].name)
+        .to eq('Class1')
+      expect(@syntax.fileElements[0].classes[4].aggregations[1].name)
+        .to eq('Class2')
+      expect(@syntax.fileElements[0].classes[4].aggregations[2].name)
+        .to eq('Class3')
     end
 
   end