kuniri 0.0.1

data/spec/core/setting_spec.rb

@@ -0,0 +1,114 @@
+require_relative '../spec_helper'
+
+RSpec.describe Kuniri::Setting do
+
+  def write_kuniri_file(parameter)
+    File.open(".kuniri", 'w') do |file|
+      file.write("language" + parameter[0] + "\n")
+      file.write("source" + parameter[1] + "\n")
+      file.write("output" + parameter[2] + "\n")
+      file.write("extract" + parameter[3] + "\n")
+      file.write("log" + parameter[4] + "\n")
+    end
+  end
+
+  before :all do
+    File.open(".kuniri", 'w') do |file|
+      file.write("language:ruby" + "\n")
+      file.write("source:xpto" + "\n")
+      file.write("output:xpto/2" + "\n")
+      file.write("extract:uml,traceability" + "\n")
+      file.write("log:html\n")
+    end
+    @settings = Kuniri::Setting.create 
+  end
+
+  context "When setting is created." do
+    it "Only one reference of Setting." do
+      @settingsTwo = Kuniri::Setting.create
+      expect((@settingsTwo == @settings)).to be true
+    end
+  end
+
+  context "When configuration file is wrong." do
+    it "Wrong path, get default configuration" do
+      defaultConf = @settings.read_configuration_file("wrong/path")
+      expect(defaultConf).to include(
+            "language" => "ruby", 
+            "source" => "./", 
+            "output" => "./", 
+            "extract" => "uml",
+            "log" => "html")
+    end
+
+    it "Syntax error: not use ':'." do
+      write_kuniri_file(["=ruby", ":../app/", ":./", ">uml", ":html"])
+      expect{@settings.read_configuration_file(".kuniri")}.to raise_error(
+        Error::ConfigurationFileError)
+    end
+
+    it "Syntax error: not valid language." do
+      write_kuniri_file([":k", ":../app/", ":./", ":uml", ":html"])
+      expect{@settings.read_configuration_file(".kuniri")}.to raise_error(
+        Error::ConfigurationFileError)
+    end
+
+    it "Syntax error: wrong source directory." do
+      write_kuniri_file([":ruby", ":xpto/", ":./", ":uml", ":html"])
+      expect{@settings.read_configuration_file(".kuniri")}.to raise_error(
+        Error::ConfigurationFileError)
+    end
+
+    it "Syntax error: wrong output directory." do
+      write_kuniri_file([":ruby", ":../app/", ":xpto/", ":uml", ":html"])
+      expect{@settings.read_configuration_file(".kuniri")}.to raise_error(
+        Error::ConfigurationFileError)
+    end
+
+    it "Syntax error: wrong extract." do
+      write_kuniri_file([":ruby", ":../app/", ":./", ":umg", ":html"])
+      expect{@settings.read_configuration_file(".kuniri")}.to raise_error(
+          Error::ConfigurationFileError)
+    end
+
+  end
+
+  context "When input is correct." do
+    it "Correct return." do
+      write_kuniri_file([":ruby", ":./", ":./", ":uml", ":html"])
+      hash_config = @settings.read_configuration_file(".kuniri")
+      expect(hash_config).to include(
+            "language" => "ruby", 
+            "source" => "./", 
+            "output" => "./", 
+            "extract" => "uml",
+            "log" => "html")
+    end
+
+    it "Correct return, different parameters." do
+      write_kuniri_file([":ruby", ":./", ":./", ":uml", ":txt"])
+      hash_config = @settings.read_configuration_file(".kuniri")
+      expect(hash_config).to include(
+            "language" => "ruby", 
+            "source" => "./", 
+            "output" => "./", 
+            "extract" => "uml",
+            "log" => "txt")
+    end
+
+
+    it "Correct return: Case sensitive language." do
+      write_kuniri_file([":ruBy", ":lib/", ":./", ":uMl, traCeaBilitY", ":txt"])
+      expect(@settings.read_configuration_file(".kuniri")).to include(
+            "language" => "ruby",
+            "source" => "lib/", 
+            "output" => "./", 
+            "extract" => "uml,traceability",
+            "log" => "txt")
+    end
+  end
+
+  after :all do
+    File.delete(".kuniri")
+  end
+end

data/spec/language/abstract_container/attribute_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Attribute do
+
+  context "When not implemented" do
+    it "Get attribute" do
+      attributeAbstract = Languages::Attribute.new
+      expect{attributeAbstract.get_attribute("nothing")}.to raise_error(
+              NotImplementedError)
+    end
+  end
+
+end

data/spec/language/abstract_container/class_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Class do
+
+  context "When not implemented" do
+    it "Get class" do
+      classAbstract = Languages::Class.new
+      expect{classAbstract.get_class("nothing")}.to raise_error(
+              NotImplementedError)
+    end
+  end
+
+end

data/spec/language/abstract_container/comment_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Comment do
+
+  before :all do
+    @commentAbstract = Languages::Comment.new
+  end
+
+  context "When comment is not implemented" do
+    it "Get comment" do
+      expect{@commentAbstract.get_comment("# nothing")}.to raise_error(
+              NotImplementedError)
+    end
+
+    it "Is single line comment?" do
+      expect{@commentAbstract.is_single_line_comment?(" # Single line")}
+              .to raise_error(NotImplementedError)
+    end
+
+    it "Is multiple line comment?" do
+      expect{@commentAbstract.is_multiple_line_comment?("=begin")}
+              .to raise_error(NotImplementedError)
+    end
+
+  end
+
+  after :all do
+    @commentAbstract = nil
+  end
+
+end

data/spec/language/abstract_container/conditional_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Conditional do
+
+  context "When not implemented" do
+    it "Get conditional." do
+      conditionalAbstract = Languages::Conditional.new
+      expect{conditionalAbstract.get_conditional("if x > y")}.to raise_error(
+              NotImplementedError)
+    end
+  end
+
+end

data/spec/language/abstract_container/constructor_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Constructor do
+
+  context "When not implemented" do
+    it "Get constructor" do
+      constructorAbstract = Languages::Constructor.new
+      expect{constructorAbstract.get_constructor("xpto")}.to raise_error(
+              NotImplementedError)
+    end
+  end
+
+end

data/spec/language/abstract_container/end_block_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::EndBlock do
+
+  context "When not implemented" do
+    it "Has end of block?" do
+      endAbstract = Languages::EndBlock.new
+      expect{endAbstract.has_end_of_block?("end")}.to raise_error(
+              NotImplementedError)
+    end
+  end
+
+
+end

data/spec/language/abstract_container/module_namespace_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::ModuleNamespace do
+
+  context "When not implemented" do
+    it "Get module" do
+      moduleAbstract = Languages::ModuleNamespace.new
+      expect{moduleAbstract.get_module("module Nothing")}.to raise_error(
+              NotImplementedError)
+    end
+  end
+
+end

data/spec/language/abstract_container/repetition_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Repetition do
+
+  context "When not implemented" do
+    it "Get repetition." do
+      repetitionAbstract = Languages::Repetition.new
+      expect{repetitionAbstract.get_repetition("do")}.to raise_error(
+              NotImplementedError)
+    end
+  end
+
+end

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

@@ -0,0 +1,32 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::AttributeData do
+
+  before :all do
+    @attributeData = Languages::AttributeData.new("xpto")
+  end
+
+  context "# Attribute data" do
+    it "Get name" do
+      expect(@attributeData.name).to eq("xpto")
+
+      @attributeData.name = "banana"
+      expect(@attributeData.name).to eq("banana")
+    end
+
+    it "Get visibility" do
+      expect(@attributeData.visibility).to eq("public")
+
+      @attributeData.visibility = "private"
+      expect(@attributeData.visibility).to eq("private")
+
+      @attributeData.visibility = "protected"
+      expect(@attributeData.visibility).to eq("protected")
+    end
+  end 
+
+  after :all do
+    @attributeData = nil
+  end
+
+end 

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

@@ -0,0 +1,121 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::ClassData do
+
+  before :each do
+    @classData = Languages::ClassData.new
+    @classData.name = "Xpto"
+  end
+
+  context "When set and get class name" do
+
+    it "Get class name." do
+      expect(@classData.name).to eq("Xpto")
+    end
+
+    it "Set class name." do
+      @classData.name = "Abc"
+      expect(@classData.name).to eq("Abc")
+    end
+
+    it "Visibility." do
+      expect(@classData.visibility).to eq("public")
+
+      @classData.visibility = "private"
+      expect(@classData.visibility).to eq("private")
+    end
+  end
+
+  RSpec.shared_examples "Add attribute" do |attributes, description|
+
+    it ": #{description}" do
+
+      listOfAttributes = []
+
+      attributes.each do |nameElement|
+        listOfAttributes.push(Languages::AttributeData.new(nameElement))
+      end
+ 
+      @classData.add_attribute(listOfAttributes)
+
+      attributeList = @classData.attributes
+      listResult = []
+
+      attributeList.each do |element|
+        listResult.push(element.name)
+      end
+
+      expect(listResult).to match_array(attributes)
+    end
+
+  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
+
+      methods.each do |element|
+        method = Languages::FunctionData.new(element)
+        @classData.add_method(method)
+      end
+
+      methodList = @classData.get_methods
+      listResult = []
+      methodList.each do |element|
+        listResult.push(element.name)
+      end
+      expect(listResult).to match_array(methods)
+    end
+
+  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
+
+end

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

@@ -0,0 +1,34 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::ConditionalData do
+
+  before :each do
+    @conditionalData = Languages::ConditionalData.new
+  end
+
+  context "When if conditional." do
+    it "Set type." do
+      @conditionalData.type = "if"
+      expect(@conditionalData.type).to eq("if")
+    end
+
+    it "Simple expression." do
+      @conditionalData.expression = "x > 3"
+      expect(@conditionalData.expression).to eq("x > 3")
+
+      @conditionalData.expression = "5 < 3"
+      expect(@conditionalData.expression).to eq("5 < 3")
+
+      @conditionalData.expression = "abc == 'x'"
+      expect(@conditionalData.expression).to eq("abc == 'x'")
+
+      @conditionalData.expression = "x >= 3"
+      expect(@conditionalData.expression).to eq("x >= 3")
+    end
+  end
+
+  after :each do
+    @conditional = nil
+  end
+
+end 

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

@@ -0,0 +1,46 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::ConstructorData do
+
+  before :each do
+    @constructorData = Languages::ConstructorData.new("initialize")
+  end
+
+  context "When constructor without parameters" do
+    it "Constructor name" do
+      @constructorData.name = "initialize"
+      expect(@constructorData.name).to eq("initialize")
+    end
+  end
+
+  context "When constructor has parameter" do
+    it "Add 1 attributes." do
+      @constructorData.add_parameters("value1")
+      attributes = @constructorData.parameters
+      expect(attributes).to match_array(["value1"])
+    end
+
+    it "Add 2 attributes." do
+      @constructorData.add_parameters("value1")
+      @constructorData.add_parameters("value2")
+      attributes = @constructorData.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"
+      @constructorData.add_conditional(condiditonal)
+      expect(@constructorData.conditionals[0].instance_of?(
+              Languages::ConditionalData)).to eq(true)
+    end
+  end
+
+  after :each do
+    @constructorData = nil
+  end
+
+end

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

@@ -0,0 +1,26 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::ExternRequirementData do
+
+  before :all 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")
+    end
+  end
+
+  context "When set path" do
+    it "Set path." do
+      @externRequirement.setPath("xpto")
+      expect(@externRequirement.name).to eq("xpto")
+    end
+  end 
+
+  after :all do
+    @externRequirement = nil
+  end
+
+end 

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

@@ -0,0 +1,91 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::FileElement do
+
+  before :each do
+    @fileElement = Languages::FileElement.new ("test")
+    @globalFunction1 = Languages::FunctionData.new("xpto")
+    @globalFunction2 = Languages::FunctionData.new("second")
+    @globalVariable1 = [Languages::VariableGlobalData.new("var1")]
+    @globalVariable2 = [Languages::VariableGlobalData.new("var2")]
+    @externFile1 = Languages::ExternRequirementData.new ("/dir/1")
+    @externFile2 = Languages::ExternRequirementData.new ("/dir/2")
+    @class1 = Languages::ClassData.new
+  end
+
+  context "When add global function." do
+
+    it "Add one global function" do
+      @fileElement.add_global_function(@globalFunction1)
+      expect(@fileElement.global_functions[0].name == "xpto").to be true
+    end
+
+    it "Add two global functions" do
+      @fileElement.add_global_function(@globalFunction1)
+      @fileElement.add_global_function(@globalFunction2)
+      functionName = []
+      @fileElement.global_functions.each do |function|
+        functionName.push(function.name)
+      end
+      expect(functionName).to match_array(["xpto", "second"])
+    end
+
+    it "Add Non function data" do
+      @fileElement.add_global_function("xpto")
+      expect(@fileElement.global_functions).to match_array([])
+    end
+
+  end
+
+  context "When add global variable." do
+
+    it "Add one global variable." do
+      @fileElement.add_global_variable(@globalVariable1)
+      expect(@fileElement.global_variables[0].name == "var1").to be true
+    end
+
+    it "Add two global variable." do
+      @fileElement.add_global_variable(@globalVariable1)
+      @fileElement.add_global_variable(@globalVariable2)
+      variables = []
+      @fileElement.global_variables.each do |variable|
+        variables.push(variable.name)
+      end
+      expect(variables).to match_array(["var1", "var2"])
+    end
+
+    it "Add non global variable." do
+      @fileElement.add_global_variable(["xpto"])
+      expect(@fileElement.global_variables).to match_array([])
+    end
+
+  end
+
+  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
+    end
+
+    it "Add two external elements." do
+      @fileElement.add_extern_requirement(@externFile1)
+      @fileElement.add_extern_requirement(@externFile2)
+      extern = []
+      @fileElement.extern_requirements.each do |externs|
+        extern.push(externs.name)
+      end
+      expect(extern).to match_array(["/dir/1", "/dir/2"])
+    end
+
+    it "Add non extern requirement." do
+      @fileElement.add_extern_requirement("xpto")
+      expect(@fileElement.extern_requirements).to match_array([])
+    end
+
+  end
+
+  after :each do
+    @fileElement = nil
+  end
+
+end 

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

@@ -0,0 +1,22 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::FunctionData do
+
+  before :all do
+    @functionData = Languages::FunctionData.new("globalFunction")
+  end
+
+  context "When function has no parameter" do
+    it "Set function name" do
+      expect(@functionData.name).to eq("globalFunction")
+
+      @functionData.name = "xpto"
+      expect(@functionData.name).to eq("xpto")
+    end
+  end
+
+  after :all do
+    @functionData = nil
+  end
+
+end

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

@@ -0,0 +1,20 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::ModuleNamespace do
+
+  before :all do
+    @moduleNamespace = Languages::ModuleNamespaceData.new("Simple")
+  end
+
+  context "Module simple behavior." do
+    it "Set name" do
+      @moduleNamespace.name = "Abc"
+      expect(@moduleNamespace.name).to eq("Abc")
+    end
+  end
+
+  after :all do
+    @moduleNamespace = nil
+  end
+
+end

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

@@ -0,0 +1,34 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::RepetitionData do
+
+  before :each do
+    @repetitionData = Languages::RepetitionData.new
+  end
+
+  context "When if conditional." do
+    it "Set type." do
+      @repetitionData.type = "while"
+      expect(@repetitionData.type).to eq("while")
+    end
+
+    it "Simple expression." do
+      @repetitionData.expression = "gets"
+      expect(@repetitionData.expression).to eq("gets")
+
+      @repetitionData.expression = "5 < 3"
+      expect(@repetitionData.expression).to eq("5 < 3")
+
+      @repetitionData.expression = "abc == 'x'"
+      expect(@repetitionData.expression).to eq("abc == 'x'")
+
+      @repetitionData.expression = "x >= 3"
+      expect(@repetitionData.expression).to eq("x >= 3")
+    end
+  end
+
+  after :each do
+    @repetitionData = nil
+  end
+
+end