kuniri 0.0.1

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

@@ -0,0 +1,39 @@
+require_relative '../../../spec_helper'
+
+RSpec.describe Languages::VariableGlobalData do
+
+  before :all do
+    @variableData = Languages::VariableGlobalData.new("abc")
+  end
+
+  context "Get name" do
+    it "Check correct name" do
+      expect(@variableData.name).to eq("abc")
+
+      @variableData.name = "newName"
+      expect(@variableData.name).to eq("newName")
+    end
+  end
+
+  context "Get value" do
+    it "Check value" do
+      @variableData.value = 1
+      expect(@variableData.value).to eq(1)
+
+      @variableData.value = "valueOne"
+      expect(@variableData.value).to eq("valueOne")
+    end
+  end
+
+  context "Get type" do
+    it "Check type value" do
+      @variableData.type = "array"
+      expect(@variableData.type).to eq("array")
+    end
+  end
+
+  after :all do
+    @variableData = nil
+  end
+
+end

data/spec/language/language_factory_spec.rb

@@ -0,0 +1,64 @@
+require_relative '../spec_helper'
+
+RSpec.describe Languages::LanguageFactory do
+
+  before :all do
+    @factory = Languages::LanguageFactory.new
+  end
+
+  context "When have supprt to language." do
+    it "Ruby support." do
+      expect(@factory.get_language("ruby").is_a?(Languages::RubySyntax))
+              .to be true
+    end
+  end
+
+  context "When have not support." do
+    it "Python support." do
+      expect{@factory.get_language("python")}.to raise_error(
+            Error::LanguageError)
+    end
+
+    it "vhdl support." do
+      expect{@factory.get_language("vhdl")}.to raise_error(
+            Error::LanguageError)
+    end
+
+    it "C support." do
+      expect{@factory.get_language("c")}.to raise_error(
+            Error::LanguageError)
+    end
+
+    it "C++ support." do
+      expect{@factory.get_language("cplusplus")}.to raise_error(
+            Error::LanguageError)
+    end
+
+    it "Java support." do
+      expect{@factory.get_language("java")}.to raise_error(
+            Error::LanguageError)
+    end
+
+    it "Assembly arm support." do
+      expect{@factory.get_language("assemblyarm")}.to raise_error(
+            Error::LanguageError)
+    end
+
+    it "PHP support." do
+      expect{@factory.get_language("php")}.to raise_error(
+            Error::LanguageError)
+    end
+
+    it "Nothing." do
+      expect{@factory.get_language("")}.to raise_error(
+            Error::LanguageError)
+    end
+
+
+  end
+
+  after :all do
+    @factory = nil
+  end
+
+end

data/spec/language/language_spec.rb

@@ -0,0 +1,74 @@
+require_relative '../spec_helper'
+
+RSpec.describe Languages::Language do
+
+  before :all do
+    @abstractLanguage = Languages::Language.new
+  end
+
+  context 'When try to call analyse_source' do
+    it "Try to call unimplemented method." do
+      expect{@abstractLanguage.analyse_source}.to raise_error(
+        NotImplementedError)
+    end
+  end
+
+  context 'When try to call comment_extract' do
+    it "Try to call comment_extract in abstract class." do
+      expect{@abstractLanguage.comment_extract}.to raise_error(
+        NotImplementedError)
+    end
+  end
+
+  context 'When try to call method_extract' do
+    it "Try to call method_extract" do
+      expect{@abstractLanguage.method_extract}.to raise_error(
+        NotImplementedError)
+    end
+  end
+
+  context "When try to call class_extract" do
+    it "Try to call class_extract" do
+      expect{@abstractLanguage.class_extract}.to raise_error(
+        NotImplementedError)
+    end
+  end
+
+  context "When try to call attribute_extract" do
+    it "Try to call attribute_extract" do
+      expect{@abstractLanguage.attribute_extract}.to raise_error(
+        NotImplementedError)
+    end
+  end
+
+  context "When try to call global_variable_extract" do
+    it "Try to call global_variable_extract." do
+      expect{@abstractLanguage.global_variable_extract}.to raise_error(
+        NotImplementedError)
+    end
+  end
+
+  context "When try to call extern_requirement_extract" do
+    it "Try to call extern_requirement_extract" do
+      expect{@abstractLanguage.extern_requirement_extract}.to raise_error(
+        NotImplementedError)
+    end
+  end
+
+  context "When try to call get_name" do
+    it "Try to call get_name" do
+      expect(@abstractLanguage.get_name).to eq(nil)
+    end
+  end
+
+  context "When try to call get_path" do
+    it "Try to call get_path" do
+      expect(@abstractLanguage.get_path).to eq(nil)
+    end
+  end
+
+  after :all do
+    @abstractLanguage = nil
+  end
+
+end

data/spec/language/ruby/attribute_ruby_spec.rb

@@ -0,0 +1,126 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::AttributeRuby do
+
+  before :all do
+    @rubyAttr = Languages::Ruby::AttributeRuby.new
+    @singleResult = "value"
+    @multiResult = ["value1", "value2", "value3", "value4"]
+  end
+
+  context "When is a single attribute with @" do
+    it "Simple case with @" do
+      captured = @rubyAttr.get_attribute("@value")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+
+    it "Whitespace before" do
+      captured = @rubyAttr.get_attribute("       @value")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+
+    it "Between whitespace" do
+      captured = @rubyAttr.get_attribute("    @value  ")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+  end
+
+  context "When is a single attribute with attr_e" do
+    it "With attr_write" do
+      captured = @rubyAttr.get_attribute("attr_write :value")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+
+    it "With attr_read" do
+      captured = @rubyAttr.get_attribute("attr_read :value")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+
+    it "With attr_accessor" do
+      captured = @rubyAttr.get_attribute("attr_accessor :value")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+
+    it "With whitespace before attr_write" do
+      captured = @rubyAttr.get_attribute("    attr_write :value")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+
+    it "With whitespace before attr_write" do
+      captured = @rubyAttr.get_attribute("  attr_write :value")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+
+    it "With whitespace before and after attr_read" do
+      captured = @rubyAttr.get_attribute("  attr_read :value  ")[0]
+      expect(captured.name).to eq(@singleResult)
+    end
+  end
+
+  RSpec.shared_examples "Multiple declaration" do |input, description|
+
+    it ": #{description}" do
+      listResult = []
+      capturedList = @rubyAttr.get_attribute(input)
+      capturedList.each do |element|
+        listResult.push(element.name)
+      end
+      expect(listResult).to match_array(@multiResult)
+    end
+
+  end
+
+  context "When multiple declarations with comma" do
+    input = "@value1, @value2, @value3, @value4"
+    message = "Use only one space."
+    include_examples "Multiple declaration", input, message
+
+    message = "Whitespace in the beginning."
+    include_examples "Multiple declaration", "     " + input, message
+
+    message = "Whitespace in the end."
+    include_examples "Multiple declaration", input + "     ", message
+
+    message = "Whitespace in the beginning and in the end."
+    include_examples "Multiple declaration", "  " + input + " ", message
+
+    message = "White space after comma."
+    include_examples "Multiple declaration", input.gsub(/,/, ", "), message
+
+    message = "Whitespace before and after comma."
+    include_examples "Multiple declaration", input.gsub(/,/, " , "), message
+
+    message = "Many whitespace before and after comma."
+    include_examples "Multiple declaration", input.gsub(/,/, "   ,   "), message
+
+    input = "@value1 = 3, @value2 = 1, @value3 = 324, @value4=28"
+    message = "Assignment."
+    include_examples "Multiple declaration", input, message
+
+    input = "@value1 = 3, @value2 = 1, @value3, @value4=28"
+    message = "Partial Assignment."
+    include_examples "Multiple declaration", input, message
+ end
+
+  context "# Multiple declaration (equal)" do
+    input = "@value1 = @value2 = @value3 = @value4"
+    message = "Separated by equal."
+    include_examples "Multiple declaration", input, message
+
+    message = "Whitespace in the beginning."
+    include_examples "Multiple declaration", "      " + input, message
+
+    message = "Whitespace in the end."
+    include_examples "Multiple declaration", input + "          "
+
+    message = "Whitespace in before and after the input."
+    include_examples "Multiple declaration", "       " + input + "   ", message
+
+    message = "Whitespace between equal."
+    include_examples "Multiple declaration", input.gsub(/=/, "   =  "), message
+  end
+
+  after :all do
+    @rubyAttr = nil
+  end
+end

data/spec/language/ruby/class_ruby_spec.rb

@@ -0,0 +1,102 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::ClassRuby do
+
+  before :all do 
+    @classRuby = Languages::Ruby::ClassRuby.new
+  end
+
+  context "When is class without inheritance" do
+    it "Ordinary class declaration." do
+      classNameCaptured = @classRuby.get_class("class Xpto").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration with whitespace." do
+      classNameCaptured = @classRuby.get_class("     class      Xpto").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration between whitespace." do
+      classNameCaptured = @classRuby.get_class("     class      Xpto   ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration with whitespace in the beginning." do
+      classNameCaptured = @classRuby.get_class("        class Xpto").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration with whitespace in the end." do
+      classNameCaptured = @classRuby.get_class("class Xpto        ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration delimited by whitespace." do
+      classNameCaptured = @classRuby.get_class("  class  Xpto      ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration with a few whitespace." do
+      classNameCaptured = @classRuby.get_class(" class Xpto  ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration with whitespace in the beginning." do
+      classNameCaptured = @classRuby.get_class(" class Xpto").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration ended with whitespace." do
+      classNameCaptured = @classRuby.get_class("class  Xpto  ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration with many whitespace." do
+      classNameCaptured = @classRuby.get_class(" class  Xpto ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class declaration with tab." do
+      classNameCaptured = @classRuby.get_class("    class  Xpto  ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+  end
+
+  context "When with inheritance" do
+    it "Simple class 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
+      classNameCaptured = @classRuby.get_class("     class   Xpto < Abc").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class 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
+      classNameCaptured = @classRuby.get_class("   class   Xpto < Abc ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+
+    it "Class 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
+      classNameCaptured = @classRuby.get_class("  class   Xpto < Abc   ").name
+      expect(classNameCaptured).to eq("Xpto")
+    end
+  end
+
+  after :all do
+    @classRuby = nil
+  end
+
+end

data/spec/language/ruby/comment_ruby_spec.rb

@@ -0,0 +1,78 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::CommentRuby do
+
+  before :all do
+    @rubyComment = Languages::Ruby::CommentRuby.new
+  end
+
+  context "When it is a single line comment." do
+
+    it "Simple case of single line comment." do
+      comment = @rubyComment.get_comment("# Comment 1")
+      expect(comment).to eq(" Comment 1")
+
+      comment = @rubyComment.get_comment("# Comment number 2")
+      expect(comment).to eq(" Comment number 2")
+    end
+
+    it "Comment with multiple spaces." do
+      comment = @rubyComment.get_comment("              # Comment 1")
+      expect(comment).to eq(" Comment 1")
+
+      comment = @rubyComment.get_comment("      #       Comment 2")
+      expect(comment).to eq("       Comment 2")
+    end
+
+    it "Check if is a single line comment." do
+      comment = @rubyComment.is_single_line_comment?("  # Comment")
+      expect(comment).to eq(true)
+
+      comment = @rubyComment.is_single_line_comment?("          # Comment  ")
+      expect(comment).to eq(true)
+
+      comment = @rubyComment.is_single_line_comment?(" =begin")
+      expect(comment).to eq(false)
+    end
+
+    it "No comment." do
+      comment = @rubyComment.get_comment("class Xpto")
+      expect(comment).to eq(nil)
+
+      comment = @rubyComment.get_comment("@value")
+      expect(comment).to eq(nil)
+    end
+
+  end
+
+  context "When it is a multiple line comment" do
+
+    it "Simple case that indicates multiple line." do
+      comment = @rubyComment.is_multiple_line_comment?("=begin")
+      expect(comment).to eq(true)
+
+      comment = @rubyComment.is_multiple_line_comment?("      =begin")
+      expect(comment).to eq(false)
+
+      comment = @rubyComment.is_multiple_line_comment?("              =begin ")
+      expect(comment).to eq(false) 
+    end
+
+    it "Find final of multiple line comment." do
+      comment = @rubyComment.is_multiple_line_comment_end?(" =end")
+      expect(comment).to eq(false)
+
+      comment = @rubyComment.is_multiple_line_comment_end?("=end")
+      expect(comment).to eq(true)
+
+      comment = @rubyComment.is_multiple_line_comment_end?("no")
+      expect(comment).to eq(false)
+    end
+
+  end
+
+  after :all do
+    @rubyComment = nil
+  end
+
+end

data/spec/language/ruby/conditional_ruby_spec.rb

@@ -0,0 +1,106 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::ConditionalRuby do
+
+  before :each do
+    @conditionalRuby = Languages::Ruby::ConditionalRuby.new
+  end
+
+  context "When it is if statment." do
+    it "Simple if statment." do
+      input = "if x < 3"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("x < 3")
+
+      input = "if 2 < 3"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("2 < 3")
+
+      input = "if abc && xpto"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("abc && xpto")
+
+      input = "if x == 222222"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("x == 222222")
+    end
+
+    it "Simple if statment with spaces." do
+      input = "                         if x == y"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("x == y")
+
+      input = "    if k && u &&  y || x         "
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("k && u &&  y || x")
+
+      input = "  if     k && u  &&                      y"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("k && u  &&                      y")
+
+      input = " if   k"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("k")
+    end
+
+  end
+
+  context "Using unless statment" do
+    it "Simple unless statment." do
+      input = "unless a > b"
+      unlessCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(unlessCaptured).to eq("a > b")
+    end
+
+    it "Simple unless statment with spaces." do
+      input = "                 unless   a  >   b "
+      unlessCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(unlessCaptured).to eq("a  >   b")
+
+      input = "            unless   a      &&      b "
+      unlessCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(unlessCaptured).to eq("a      &&      b")
+    end
+  end
+
+  context "Using elsif" do
+    it "Simple elsif statment." do
+      input = "elsif n > m"
+      elsifCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(elsifCaptured).to eq("n > m")
+    end
+
+    it "Simple elsif statement with spaces." do
+      input = "                 elsif n > m   "
+      elsifCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(elsifCaptured).to eq("n > m")
+    end
+  end
+
+  context "When is case statment." do
+    it "Simple case statment." do
+      input = "case options"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("options")
+
+      input = "case abc"
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("abc")
+    end
+
+    it "Case with spaces" do
+      input = "                                              case    abc  "
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("abc")
+
+      input = " case     abc         "
+      conditionalCaptured = @conditionalRuby.get_conditional(input).expression
+      expect(conditionalCaptured).to eq("abc")
+    end
+  end 
+
+  after :each do
+    @conditionalRuby = nil
+  end
+
+end

data/spec/language/ruby/constructor_ruby_spec.rb

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