kuniri 0.0.1 → 0.2

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

@@ -35,7 +35,7 @@ RSpec.describe Languages::ClassData do
       attributes.each do |nameElement|
         listOfAttributes.push(Languages::AttributeData.new(nameElement))
       end
- 
+
       @classData.add_attribute(listOfAttributes)
 
       attributeList = @classData.attributes
@@ -50,22 +50,6 @@ RSpec.describe Languages::ClassData do
 
   end
 
-  context "When add attribute" do
-    it "No attribute." do
-      attributes = @classData.get_attributes
-      expect(attributes).to eq([])
-    end
-
-    message = "Add 1 element."
-    include_examples "Add attribute", ["value1"], message
-
-    message = "Add 2 element."
-    include_examples "Add attribute", ["value1", "value2"], message
-
-    message = "Add 3 element."
-    include_examples "Add attribute", ["value1", "value2", "value3"], message
-  end
-
   RSpec.shared_examples "Add method" do |methods, description|
 
     it ": #{description}" do
@@ -85,35 +69,6 @@ RSpec.describe Languages::ClassData do
 
   end
 
-
-  context "When add method" do
-    it "No method" do
-      methods = @classData.get_methods
-      expect(methods).to eq([])
-    end
-
-    message = "Add 1 method."
-    include_examples "Add method", ["method1"], message
-
-    message = "Add 2 method"
-    include_examples "Add method", ["method1", "method2"], message
-  end
-
-  context "When add constructor" do
-    it "Add constructors" do
-      constructorAdd = Languages::FunctionData.new("constructor")
-      @classData.add_constructor(constructorAdd)
-      constructors = @classData.get_constructors
-      expect(constructors[0].name == "constructor").to be true
-    end
-
-    it "Try to add non-constructor" do
-      @classData.add_constructor("xpto")
-        expect(@classData.get_constructors).to match_array([])
-    end
-
-  end
-
   after :each do
     @classData = nil
   end

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

@@ -34,11 +34,41 @@ RSpec.describe Languages::ConstructorData do
       condiditonal.type = "IF"
       condiditonal.expression = "x > 3"
       @constructorData.add_conditional(condiditonal)
-      expect(@constructorData.conditionals[0].instance_of?(
-              Languages::ConditionalData)).to eq(true)
+      all = @constructorData.managerCondAndLoop.basicStructure
+      expect(all[0].instance_of?(Languages::ConditionalData)).to eq(true)
     end
   end
 
+  context "When instantiating" do
+    it "Does not set name" do
+      @constructorData = Languages::ConstructorData.new(nil)
+      expect(@constructorData.name).to be_nil
+      @constructorData = Languages::ConstructorData.new(1)
+      expect(@constructorData.name).to be_nil
+    end
+  end
+
+  context "Copy from FunctionAbstract to constructor" do
+    it "Simple 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)
+
+      @constructorData << lalala
+      expect(@constructorData.name).to eq("lalala")
+      expect(@constructorData.comments).to eq("abc")
+      expect(@constructorData.comments).to eq("abc")
+      all = @constructorData.managerCondAndLoop.basicStructure
+      expect(all[0].instance_of?(Languages::ConditionalData)).to eq(true)
+      expect(@constructorData.type).to eq("CONSTRUCTOR")
+    end
+
+  end
+
   after :each do
     @constructorData = nil
   end

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

@@ -2,25 +2,49 @@ require_relative '../../../spec_helper'
 
 RSpec.describe Languages::ExternRequirementData do
 
-  before :all do
+  before :each do
     @externRequirement = Languages::ExternRequirementData.new("xpto")
   end
 
   context "Using constructor to create data container." do
     it "Create container" do
-      expect(@externRequirement.name).to eq("xpto")
+      expect(@externRequirement.library).to eq("xpto")
+    end
+
+    it "Does not set name" do
+      @externRequirement = Languages::ExternRequirementData.new(nil)
+      expect(@externRequirement.library).to be_nil
+      @externRequirement = Languages::ExternRequirementData.new(1)
+      expect(@externRequirement.library).to be_nil
+    end
+  end
+
+  context "When set library" do
+    it "Set library." do
+      @externRequirement.set_library("spec/samples/emptyFile")
+      expect(@externRequirement.library).to eq("spec/samples/emptyFile")
     end
   end
 
   context "When set path" do
     it "Set path." do
-      @externRequirement.setPath("xpto")
-      expect(@externRequirement.name).to eq("xpto")
+      @externRequirement.set_library("xpto")
+      expect(@externRequirement.library).to eq("xpto")
+    end
+
+    it "Does not set library" do
+      @externRequirement = Languages::ExternRequirementData.new("xpto")
+      @externRequirement.set_library(1)
+      expect(@externRequirement.library).to eq("xpto")
+      @externRequirement.set_library(nil)
+      expect(@externRequirement.library).to eq("xpto")
+      @externRequirement.set_library("")
+      expect(@externRequirement.library).to eq("xpto")
     end
-  end 
+  end
 
-  after :all do
+  after :each do
     @externRequirement = nil
   end
 
-end 
+end

data/spec/language/container_data/structured_and_oo/{file_element_spec.rb → file_element_data_spec.rb}

@@ -1,13 +1,14 @@
 require_relative '../../../spec_helper'
 
-RSpec.describe Languages::FileElement do
+RSpec.describe Languages::FileElementData do
 
   before :each do
-    @fileElement = Languages::FileElement.new ("test")
+    @fileElement = Languages::FileElementData.new ("test")
     @globalFunction1 = Languages::FunctionData.new("xpto")
     @globalFunction2 = Languages::FunctionData.new("second")
     @globalVariable1 = [Languages::VariableGlobalData.new("var1")]
     @globalVariable2 = [Languages::VariableGlobalData.new("var2")]
+    @globalVariable3 = Languages::VariableGlobalData.new("var3")
     @externFile1 = Languages::ExternRequirementData.new ("/dir/1")
     @externFile2 = Languages::ExternRequirementData.new ("/dir/2")
     @class1 = Languages::ClassData.new
@@ -54,6 +55,11 @@ RSpec.describe Languages::FileElement do
       expect(variables).to match_array(["var1", "var2"])
     end
 
+    it "Add one global variable as single parameter." do
+      @fileElement.add_global_variable(@globalVariable3)
+      expect(@fileElement.global_variables[0].name == "var3").to be true
+    end
+
     it "Add non global variable." do
       @fileElement.add_global_variable(["xpto"])
       expect(@fileElement.global_variables).to match_array([])
@@ -64,7 +70,7 @@ RSpec.describe Languages::FileElement do
   context "When add external files." do
     it "Add one external element." do
       @fileElement.add_extern_requirement(@externFile1)
-      expect(@fileElement.extern_requirements[0].name == "/dir/1").to be true
+      expect(@fileElement.extern_requirements[0].library == "/dir/1").to be true
     end
 
     it "Add two external elements." do
@@ -72,7 +78,7 @@ RSpec.describe Languages::FileElement do
       @fileElement.add_extern_requirement(@externFile2)
       extern = []
       @fileElement.extern_requirements.each do |externs|
-        extern.push(externs.name)
+        extern.push(externs.library)
       end
       expect(extern).to match_array(["/dir/1", "/dir/2"])
     end
@@ -84,8 +90,18 @@ RSpec.describe Languages::FileElement do
 
   end
 
+  context "When instantiating" do
+    it "Does not set name" do
+      @fileElement = Languages::FileElementData.new(nil)
+      expect(@fileElement.name).to be_nil
+      @fileElement = Languages::FileElementData.new(1)
+      expect(@fileElement.name).to be_nil
+    end
+
+  end
+
   after :each do
     @fileElement = nil
   end
 
-end 
+end

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

@@ -0,0 +1,213 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::FunctionAbstract do
+
+  before :each do
+    @functionAbstract = Languages::FunctionAbstract.new "Test"
+    @conditional = Languages::ConditionalData.new
+    @repetition = Languages::RepetitionData.new
+  end
+
+  context "When adding a parameter" do
+    it "Adds a parameter" do
+      @functionAbstract.add_parameters("a")
+      expect(@functionAbstract.parameters).to eq(["a"])
+    end
+
+    it "Adds a parameter with assignment" do
+      @functionAbstract.add_parameters({"key" => "a"})
+      expect(@functionAbstract.parameters).to eq([{"key" => "a"}])
+    end
+
+    it "Adds multiple parameters" do
+      @functionAbstract.add_parameters("a")
+      @functionAbstract.add_parameters("b")
+      @functionAbstract.add_parameters("c")
+      expect(@functionAbstract.parameters).to eq(["a", "b", "c"])
+    end
+
+    it "Adds multiple parameters with assignment" do
+      @functionAbstract.add_parameters({"key1" => "a"})
+      @functionAbstract.add_parameters({"key2" => "b"})
+      @functionAbstract.add_parameters({"key3" => "c"})
+      expect(@functionAbstract.parameters).to eq([{"key1" => "a"},
+                                                  {"key2" => "b"},
+                                                  {"key3" => "c"}])
+    end
+
+    it "adds an integer as a parameter" do
+      @functionAbstract.add_parameters(12)
+      expect(@functionAbstract.parameters).to_not eq([12])
+    end
+
+    it "Adds a hash with more than one element as a parameter" do
+      @functionAbstract.add_parameters({"key1" => "a", "key2" => "b"})
+      expect(@functionAbstract.parameters).to_not eq([{"key1" => "a",
+                                                       "key2" => "b"}])
+    end
+
+  end
+
+  context "When adding a conditional" do
+    it "Adds a conditional" do
+      @functionAbstract.add_conditional(@conditional)
+      functionConditional = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(functionConditional).to eq([@conditional])
+    end
+
+    it "Adds a string as a conditional should fail" do
+      @functionAbstract.add_conditional("xpto")
+      functionConditional = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(functionConditional).to_not eq(["xpto"])
+    end
+
+    it "Adds a set of conditional" do
+      conditionals = []
+      for index in 0..5 do
+        conditionals[index] = Languages::ConditionalData.new
+        conditionals[index].expression = "xpto == #{index}"
+        conditionals[index].type = Languages::IF_LABEL
+        @functionAbstract.add_conditional(conditionals[index])
+      end
+      allConditionals = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(allConditionals).to match_array(conditionals)
+    end
+
+    it "Add a set of conditionals with different level" do
+      conditionals = []
+      for index in 0..3 do
+        conditionals[index]  = Languages::ConditionalData.new
+        conditionals[index].type = Languages::IF_LABEL
+      end
+
+      @functionAbstract.add_conditional(conditionals[0])
+      @functionAbstract.add_conditional(conditionals[1], Languages::DOWN_LEVEL)
+      @functionAbstract.add_conditional(conditionals[2], Languages::DOWN_LEVEL)
+      @functionAbstract.add_conditional(conditionals[3], Languages::UP_LEVEL)
+
+      allConditional = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(allConditional[0].level).to eq(0)
+      expect(allConditional[1].level).to eq(1)
+      expect(allConditional[2].level).to eq(2)
+      expect(allConditional[3].level).to eq(1)
+
+    end
+  end
+
+  context "When adding a repetition" do
+    it "Adds a repetition" do
+      @functionAbstract.add_repetition(@repetition)
+      functionLoop = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(functionLoop).to eq([@repetition])
+    end
+
+    it "Adds a string as a repetition should fail" do
+      @functionAbstract.add_repetition("xpto")
+      functionLoop = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(functionLoop).to_not eq(["xpto"])
+    end
+
+    it "Add a set of loops" do
+      loops = []
+      for index in 0..5 do
+        loops[index] = Languages::RepetitionData.new
+        loops[index].type = Languages::FOR_LABEL
+        loops[index].expression = "true"
+        @functionAbstract.add_repetition(loops[index])
+      end
+      allLoops = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(allLoops).to match_array(loops)
+    end
+
+    it "Add a set of loops with different level" do
+      loops = []
+      for index in 0..3 do
+        loops[index] = Languages::RepetitionData.new
+        loops[index].type = Languages::WHILE_LABEL
+      end
+
+      @functionAbstract.add_repetition(loops[0])
+      @functionAbstract.add_repetition(loops[1], Languages::DOWN_LEVEL)
+      @functionAbstract.add_repetition(loops[2])
+      @functionAbstract.add_repetition(loops[3], Languages::UP_LEVEL)
+
+      allLoops = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(allLoops[0].level).to eq(0)
+      expect(allLoops[1].level).to eq(1)
+      expect(allLoops[2].level).to eq(1)
+      expect(allLoops[3].level).to eq(0)
+    end
+  end
+
+  context "Set conditional and loops mixed" do
+    it "Set conditionals and loops" do
+      conditionalOne = Languages::ConditionalData.new
+      conditionalOne.type = Languages::IF_LABEL
+      conditionalTwo = Languages::ConditionalData.new
+      conditionalTwo.type = Languages::ELSIF_LABEL
+
+      repetitionOne = Languages::RepetitionData.new
+      repetitionOne.type = Languages::FOR_LABEL
+      repetitionTwo = Languages::RepetitionData.new
+      repetitionTwo.type = Languages::WHILE_LABEL
+
+      @functionAbstract.add_conditional(conditionalOne)
+      @functionAbstract.add_repetition(repetitionOne, Languages::DOWN_LEVEL)
+      @functionAbstract.add_conditional(conditionalTwo, Languages::UP_LEVEL)
+      @functionAbstract.add_repetition(repetitionTwo, Languages::DOWN_LEVEL)
+
+      all = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(all[0].level).to eq(0)
+      expect(all[1].level).to eq(1)
+      expect(all[1].type).to eq(Languages::FOR_LABEL)
+      expect(all[2].level).to eq(0)
+      expect(all[3].level).to eq(1)
+      expect(all[3].type).to eq(Languages::WHILE_LABEL)
+    end
+
+    it "Set loops and conditionals" do
+      conditionalOne = Languages::ConditionalData.new
+      conditionalOne.type = Languages::IF_LABEL
+      conditionalTwo = Languages::ConditionalData.new
+      conditionalTwo.type = Languages::ELSIF_LABEL
+
+      repetitionOne = Languages::RepetitionData.new
+      repetitionOne.type = Languages::FOR_LABEL
+      repetitionTwo = Languages::RepetitionData.new
+      repetitionTwo.type = Languages::WHILE_LABEL
+
+      @functionAbstract.add_repetition(repetitionOne)
+      @functionAbstract.add_repetition(repetitionTwo, Languages::DOWN_LEVEL)
+      @functionAbstract.add_conditional(conditionalOne, Languages::DOWN_LEVEL)
+      @functionAbstract.add_conditional(conditionalTwo)
+
+      all = @functionAbstract.managerCondAndLoop.basicStructure
+      expect(all[0].level).to eq(0)
+      expect(all[0].type).to eq(Languages::FOR_LABEL)
+      expect(all[1].level).to eq(1)
+      expect(all[1].type).to eq(Languages::WHILE_LABEL)
+      expect(all[2].level).to eq(2)
+      expect(all[2].type).to eq(Languages::IF_LABEL)
+      expect(all[3].level).to eq(2)
+      expect(all[3].type).to eq(Languages::ELSIF_LABEL)
+
+    end
+
+  end
+
+  context "When instantiating" do
+    it "Does not set name" do
+      @functionAbstract = Languages::FunctionAbstract.new(nil)
+      expect(@functionAbstract.name).to be_nil
+      @functionAbstract = Languages::FunctionAbstract.new(1)
+      expect(@functionAbstract.name).to be_nil
+    end
+  end
+
+  after :each do
+    @functionAbstract = nil
+    @conditional = nil
+    @repetition = nil
+  end
+
+end

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

@@ -2,7 +2,7 @@ require_relative '../../../spec_helper'
 
 RSpec.describe Languages::FunctionData do
 
-  before :all do
+  before :each do
     @functionData = Languages::FunctionData.new("globalFunction")
   end
 
@@ -15,7 +15,36 @@ RSpec.describe Languages::FunctionData do
     end
   end
 
-  after :all do
+  context "When instantiating" do
+    it "Does not set name" do
+      @functionData = Languages::FunctionData.new(nil)
+      expect(@functionData.name).to be_nil
+      @functionData = Languages::FunctionData.new(1)
+      expect(@functionData.name).to be_nil
+    end
+  end
+
+  context "Copy from FunctionAbstract to FunctionData" do
+    it "Verify copy" do
+      lalala = Languages::FunctionAbstract.new("lalala")
+      lalala.comments = "abc"
+
+      condiditonal = Languages::ConditionalData.new
+      condiditonal.type = Languages::IF_LABEL
+      condiditonal.expression = "x > 3"
+      lalala.add_conditional(condiditonal)
+
+      @functionData << lalala
+      expect(@functionData.name).to eq("lalala")
+      expect(@functionData.comments).to eq("abc")
+      expect(@functionData.comments).to eq("abc")
+      all = @functionData.managerCondAndLoop.basicStructure
+      expect(all[0].instance_of?(Languages::ConditionalData)).to eq(true)
+      expect(@functionData.type).to eq("GLOBALFUNCTION")
+    end
+  end
+
+  after :each do
     @functionData = nil
   end