kuniri 0.0.1 → 0.2

data/spec/language/container_data/structured_and_oo/manager_basic_structure_data_spec.rb

@@ -0,0 +1,150 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::ManagerBasicStructureData do
+
+  before :each do
+    @manager = Languages::ManagerBasicStructureData.new
+  end
+
+  context "Simple conditionals" do
+    it "Add simple if." do
+      conditional = Languages::ConditionalData.new
+      conditional.type = Languages::IF_LABEL
+
+      @manager.add_conditional(conditional)
+      expect(@manager.basicStructure[0]).to eq(conditional)
+    end
+
+    it "Add simple if and elsif." do
+      conditional = Languages::ConditionalData.new
+      conditional.type = Languages::IF_LABEL
+      elsifConditional = Languages::ConditionalData.new
+      elsifConditional.type = Languages::ELSIF_LABEL
+
+      @manager.add_conditional(conditional)
+      @manager.add_conditional(elsifConditional)
+
+      expect(@manager.basicStructure[0].type).to eq(Languages::IF_LABEL)
+      expect(@manager.basicStructure[1].type).to eq(Languages::ELSIF_LABEL)
+    end
+
+    it "Add a sequence of if, elsif and finish with else." do
+      conditional1 = Languages::ConditionalData.new
+      conditional1.type = Languages::IF_LABEL
+      elsifConditional1 = Languages::ConditionalData.new
+      elsifConditional1.type = Languages::ELSIF_LABEL
+      elsifConditional2 = Languages::ConditionalData.new
+      elsifConditional2.type = Languages::ELSIF_LABEL
+      elseConditional3 = Languages::ConditionalData.new
+      elseConditional3.type = Languages::ELSE_LABEL
+
+      @manager.add_conditional(conditional1)
+      @manager.add_conditional(elsifConditional1)
+      @manager.add_conditional(elsifConditional2)
+      @manager.add_conditional(elseConditional3)
+
+      expect(@manager.basicStructure[0].type).to eq(Languages::IF_LABEL)
+      expect(@manager.basicStructure[1].type).to eq(Languages::ELSIF_LABEL)
+      expect(@manager.basicStructure[2].type).to eq(Languages::ELSIF_LABEL)
+      expect(@manager.basicStructure[3].type).to eq(Languages::ELSE_LABEL)
+    end
+  end
+
+  context "Simple repetitions." do
+    it "Simple repetition." do
+      repetition = Languages::RepetitionData.new
+      repetition.type = Languages::WHILE_LABEL
+      @manager.add_repetition(repetition)
+      expect(@manager.basicStructure[0].type).to eq(Languages::WHILE_LABEL)
+    end
+  end
+
+  context "Nested conditionals." do
+    it "Basic if nested, level 1." do
+      conditional1 = Languages::ConditionalData.new
+      conditional1.type = Languages::IF_LABEL
+      conditional2 = Languages::ConditionalData.new
+      conditional2.type = Languages::IF_LABEL
+      conditional3 = Languages::ConditionalData.new
+      conditional3.type = Languages::IF_LABEL
+
+      @manager.add_conditional(conditional1)
+      @manager.down_level
+      @manager.add_conditional(conditional2)
+      @manager.add_conditional(conditional3)
+
+      expect(@manager.basicStructure[0].level).to eq(0)
+      expect(@manager.basicStructure[1].level).to eq(1)
+      expect(@manager.basicStructure[2].level).to eq(1)
+    end
+
+    it "Basic nested if with elsif, level 1." do
+      conditional1 = Languages::ConditionalData.new
+      conditional1.type = Languages::IF_LABEL
+      conditional2 = Languages::ConditionalData.new
+      conditional2.type = Languages::ELSIF_LABEL
+
+      conditional3 = Languages::ConditionalData.new
+      conditional3.type = Languages::IF_LABEL
+      conditional4 = Languages::ConditionalData.new
+      conditional4.type = Languages::IF_LABEL
+      conditional5 = Languages::ConditionalData.new
+      conditional5.type = Languages::IF_LABEL
+
+      @manager.add_conditional(conditional1)
+      @manager.down_level
+      @manager.add_conditional(conditional3)
+      @manager.add_conditional(conditional4)
+      @manager.up_level
+      @manager.add_conditional(conditional2)
+      @manager.down_level
+      @manager.add_conditional(conditional5)
+
+      expect(@manager.basicStructure[0].level).to eq(0)
+      expect(@manager.basicStructure[1].level).to eq(1)
+      expect(@manager.basicStructure[2].level).to eq(1)
+      expect(@manager.basicStructure[3].level).to eq(0)
+      expect(@manager.basicStructure[4].level).to eq(1)
+    end
+
+  end
+
+  context "Nested repetitions." do
+    it "Simple repetition." do
+      repetition1 = Languages::RepetitionData.new
+      repetition1.type = Languages::WHILE_LABEL
+
+      repetition2 = Languages::RepetitionData.new
+      repetition2.type = Languages::WHILE_LABEL
+
+      @manager.add_repetition(repetition1)
+      @manager.down_level
+      @manager.add_repetition(repetition2)
+
+      expect(@manager.basicStructure[0].level).to eq(0)
+      expect(@manager.basicStructure[1].level).to eq(1)
+    end
+  end
+
+  context "Nested conditionals and repetitions." do
+    it "Simple conditional with repetition." do
+      repetition1 = Languages::RepetitionData.new
+      repetition1.type = Languages::WHILE_LABEL
+
+      conditional1 = Languages::ConditionalData.new
+      conditional1.type = Languages::IF_LABEL
+
+      @manager.add_conditional(conditional1)
+      @manager.down_level
+      @manager.add_repetition(repetition1)
+
+      expect(@manager.basicStructure[0].level).to eq(0)
+      expect(@manager.basicStructure[1].level).to eq(1)
+    end
+  end
+
+  after :each do
+    @manager = nil
+  end
+end
+

data/spec/language/container_data/structured_and_oo/method_data_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::MethodData do
+
+  before :each do
+    @methodData = Languages::MethodData.new("xpto")
+  end
+
+  context "Module simple behavior." do
+    it "Set name" do
+      @methodData.name = "Abc"
+      expect(@methodData.name).to eq("Abc")
+    end
+
+    it "Does not set name" do
+      @methodData = Languages::MethodData.new(nil)
+      expect(@methodData.name).to be_nil
+      @methodData = Languages::MethodData.new(1)
+      expect(@methodData.name).to be_nil
+    end
+  end
+
+  context "When method without parameters" do
+    it "Method name" do
+      @methodData.name = "xpto"
+      expect(@methodData.name).to eq("xpto")
+    end
+  end
+
+  context "When method has parameter" do
+    it "Add 1 attributes." do
+      @methodData.add_parameters("value1")
+      attributes = @methodData.parameters
+      expect(attributes).to match_array(["value1"])
+    end
+
+    it "Add 2 attributes." do
+      @methodData.add_parameters("value1")
+      @methodData.add_parameters("value2")
+      attributes = @methodData.parameters
+      expect(attributes).to match_array(["value1", "value2"])
+    end
+  end
+
+  context "When have codiditional statements." do
+    it "Simple case of conditional statment" do
+      condiditonal = Languages::ConditionalData.new
+      condiditonal.type = "IF"
+      condiditonal.expression = "x > 3"
+      @methodData.add_conditional(condiditonal)
+      all = @methodData.managerCondAndLoop.basicStructure
+      expect(all[0].instance_of?(Languages::ConditionalData)).to eq(true)
+    end
+  end
+
+  context "Copy from FunctionAbstract to MethodData" do
+    it "Verify copy" do
+      lalala = Languages::FunctionAbstract.new("lalala")
+      lalala.comments = "abc"
+
+      condiditonal = Languages::ConditionalData.new
+      condiditonal.type = "IF"
+      condiditonal.expression = "x > 3"
+      lalala.add_conditional(condiditonal)
+
+      @methodData << lalala
+      expect(@methodData.name).to eq("lalala")
+      expect(@methodData.comments).to eq("abc")
+      expect(@methodData.comments).to eq("abc")
+      all = @methodData.managerCondAndLoop.basicStructure
+      expect(all[0].instance_of?(Languages::ConditionalData)).to eq(true)
+      expect(@methodData.type).to eq("METHOD")
+    end
+  end
+
+  after :each do
+    @methodData = nil
+  end
+
+end

data/spec/language/container_data/structured_and_oo/module_namespace_spec.rb

@@ -1,6 +1,6 @@
 require_relative '../../../spec_helper'
 
-RSpec.describe Languages::ModuleNamespace do
+RSpec.describe Languages::ModuleNamespaceData do
 
   before :all do
     @moduleNamespace = Languages::ModuleNamespaceData.new("Simple")
@@ -11,6 +11,12 @@ RSpec.describe Languages::ModuleNamespace do
       @moduleNamespace.name = "Abc"
       expect(@moduleNamespace.name).to eq("Abc")
     end
+    it "Does not set name" do
+      @moduleNamespace = Languages::ModuleNamespaceData.new(nil)
+      expect(@moduleNamespace.name).to be_nil
+      @moduleNamespace = Languages::ModuleNamespaceData.new(1)
+      expect(@moduleNamespace.name).to be_nil
+    end
   end
 
   after :all do

data/spec/language/container_data/structured_and_oo/variable_global_data_spec.rb

@@ -32,6 +32,15 @@ RSpec.describe Languages::VariableGlobalData do
     end
   end
 
+  context "When instantiating" do
+    it "Does not set name" do
+      @variableData = Languages::VariableGlobalData.new(nil)
+      expect(@variableData.name).to be_nil
+      @variableData = Languages::VariableGlobalData.new(1)
+      expect(@variableData.name).to be_nil
+    end
+  end
+
   after :all do
     @variableData = nil
   end

data/spec/language/language_factory_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Languages::LanguageFactory do
     @factory = Languages::LanguageFactory.new
   end
 
-  context "When have supprt to language." do
+  context "When have support to language." do
     it "Ruby support." do
       expect(@factory.get_language("ruby").is_a?(Languages::RubySyntax))
               .to be true

data/spec/language/language_spec.rb

@@ -2,7 +2,7 @@ require_relative '../spec_helper'
 
 RSpec.describe Languages::Language do
 
-  before :all do
+  before :each do
     @abstractLanguage = Languages::Language.new
   end
 
@@ -55,19 +55,56 @@ RSpec.describe Languages::Language do
     end
   end
 
-  context "When try to call get_name" do
-    it "Try to call get_name" do
-      expect(@abstractLanguage.get_name).to eq(nil)
+  context "Handling nested conditional and repetitions" do
+    it "Make it more nested" do
+      expect(@abstractLanguage.countNestedCondLoop).to eq(0)
+      @abstractLanguage.moreNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(1)
+      @abstractLanguage.moreNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(2)
+    end
+
+    it "Make it less nested" do
+      expect(@abstractLanguage.countNestedCondLoop).to eq(0)
+      @abstractLanguage.moreNested
+      @abstractLanguage.moreNested
+      @abstractLanguage.moreNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(3)
+      @abstractLanguage.lessNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(2)
+      @abstractLanguage.lessNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(1)
+    end
+
+    it "Can't have negative nested" do
+      @abstractLanguage.lessNested
+      @abstractLanguage.lessNested
+      @abstractLanguage.lessNested
+      @abstractLanguage.lessNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(0)
+    end
+
+    it "Have to be nested" do
+      @abstractLanguage.moreNested
+      expect(@abstractLanguage.isNested?).to eq(true)
+    end
+
+    it "Not nested" do
+      @abstractLanguage.moreNested
+      expect(@abstractLanguage.isNested?).to eq(true)
+      @abstractLanguage.lessNested
+      expect(@abstractLanguage.isNested?).to eq(false)
     end
-  end
 
-  context "When try to call get_path" do
-    it "Try to call get_path" do
-      expect(@abstractLanguage.get_path).to eq(nil)
+    it "Reset nested" do
+      @abstractLanguage.moreNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(1)
+      @abstractLanguage.resetNested
+      expect(@abstractLanguage.countNestedCondLoop).to eq(0)
     end
   end
 
-  after :all do
+  after :each do
     @abstractLanguage = nil
   end
 

data/spec/language/ruby/aggregation_ruby_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::AggregationRuby do
+
+  before :each do
+    @rubyAggr = Languages::Ruby::AggregationRuby.new
+    @singleResult = "abc"
+  end
+
+  context "When is a single aggregation with @" do
+    it "Simple case with @" do
+      captured = @rubyAggr.get_aggregation("abc.new\n")
+      expect(captured.name).to eq(@singleResult)
+    end
+
+     it "Whitespace before" do
+       captured = @rubyAggr.get_aggregation("       abc.new\n")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+     it "With whitespace before and after" do
+       captured = @rubyAggr.get_aggregation("    abc.new  \n")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+     it "Whitespace before dot" do
+       captured = @rubyAggr.get_aggregation("abc   .new\n")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+     it "Whitespace after dot" do
+       captured = @rubyAggr.get_aggregation("abc.    new\n")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+     it "Between whitespace" do
+       captured = @rubyAggr.get_aggregation("abc     .    new\n")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+   end
+
+  context "When there is an aggregation with parameters" do
+
+     it "With a single parameter" do
+       captured = @rubyAggr.get_aggregation("abc.new a")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+     it "With multiple parameters" do
+       captured = @rubyAggr.get_aggregation("abc.new a b c")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+     it "With single parameter with parenthesis" do
+       captured = @rubyAggr.get_aggregation("abc.new(a)")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+     it "With multiple parameter with parenthesis" do
+       captured = @rubyAggr.get_aggregation("abc.new(a,b, c)")
+       expect(captured.name).to eq(@singleResult)
+     end
+
+  end
+
+  context "When there is an aggregation with parameters" do
+
+     it "Method calling with new on it" do
+       captured = @rubyAggr.get_aggregation("abc.newton")
+       expect(captured).to eq(nil)
+     end
+  end
+
+  after :each do
+    @rubyAggr = nil
+    @singleResult = nil
+  end
+
+end

data/spec/language/ruby/class_ruby_spec.rb

@@ -64,35 +64,95 @@ RSpec.describe Languages::Ruby::ClassRuby do
   end
 
   context "When with inheritance" do
-    it "Simple class inheritance." do
+    it "Simple class name w/ inheritance." do
       classNameCaptured = @classRuby.get_class("class Xpto < Abc").name
       expect(classNameCaptured).to eq("Xpto")
     end
 
-    it "Class inheritance with whitespace in the beginning." do
+    it "Simple class inheritance." do
+      classNameCaptured = @classRuby.get_class("class Xpto < Abc").inheritances
+      expect(classNameCaptured).to eq([["Abc"]])
+    end
+
+    it "Class name w/ inheritance with whitespace in the beginning." do
       classNameCaptured = @classRuby.get_class("     class   Xpto < Abc").name
       expect(classNameCaptured).to eq("Xpto")
     end
 
-    it "Class inheritance with whitespace between <." do
+    it "Class inheritance with whitespace in the beginning." do
+      classNameCaptured = @classRuby.get_class("     class   Xpto < Abc")
+                                    .inheritances
+      expect(classNameCaptured).to eq([["Abc"]])
+    end
+
+    it "Class name w/ inheritance with whitespace between <." do
       classNameCaptured = @classRuby.get_class("class Xpto   < Abc").name
       expect(classNameCaptured).to eq("Xpto")
     end
 
-    it "Class inheritance with many whitespace." do
+    it "Class inheritance with whitespace between <." do
+      classNameCaptured = @classRuby.get_class("class Xpto   < Abc")
+                                    .inheritances
+      expect(classNameCaptured).to eq([["Abc"]])
+    end
+
+    it "Class name w/ inheritance with many whitespace." do
       classNameCaptured = @classRuby.get_class("   class   Xpto < Abc ").name
       expect(classNameCaptured).to eq("Xpto")
     end
 
-    it "Class inheritance with many whitespace between <." do
+    it "Class inheritance with many whitespace." do
+      classNameCaptured = @classRuby.get_class("   class   Xpto < Abc ")
+                                    .inheritances
+      expect(classNameCaptured).to eq([["Abc"]])
+    end
+
+    it "Class name w/ inheritance with many whitespace between <." do
       classNameCaptured = @classRuby.get_class("class Xpto      <    Abc").name
       expect(classNameCaptured).to eq("Xpto")
     end
 
-    it "Class inheritance with whitespace in the corners." do
+    it "Class inheritance with many whitespace between <." do
+      classNameCaptured = @classRuby.get_class("class Xpto      <    Abc")
+                                    .inheritances
+      expect(classNameCaptured).to eq([["Abc"]])
+    end
+
+    it "Class name w/ inheritance with whitespace in the corners." do
       classNameCaptured = @classRuby.get_class("  class   Xpto < Abc   ").name
       expect(classNameCaptured).to eq("Xpto")
     end
+
+    it "Class inheritance with whitespace in the corners." do
+      classNameCaptured = @classRuby.get_class("  class   Xpto < Abc   ")
+                                    .inheritances
+      expect(classNameCaptured).to eq([["Abc"]])
+    end
+  end
+
+  context "Get inheritance" do
+
+    it "Class inheritance normal case" do
+      inheritance = @classRuby.get_class("class Xpto < Abc").inheritances[0]
+      expect(inheritance).to eq(["Abc"])
+    end
+
+    it "Inheritance with many spaces in the beginning" do
+      inheritance = @classRuby.get_class("class Xpto <    Abc").inheritances[0]
+      expect(inheritance).to eq(["Abc"])
+    end
+
+    it "Inheritance with many spaces in the end" do
+      inheritance = @classRuby.get_class("class Xpto < Abc   ").inheritances[0]
+      expect(inheritance).to eq(["Abc"])
+    end
+
+    it "Inheritance with many spaces in the beginning and in the end" do
+      inheritance = @classRuby.get_class("class Xs <   Abc   ").inheritances[0]
+      expect(inheritance).to eq(["Abc"])
+
+    end
+
   end
 
   after :all do