kuniri 0.0.1

data/spec/language/ruby/end_block_ruby_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::EndBlockRuby do
+
+  before :all do
+    @endBlock = Languages::Ruby::EndBlockRuby.new
+  end
+
+  context "When the end of block is isolate in one line." do
+    it "No end in the line" do
+      isEnd = @endBlock.has_end_of_block?("class Xpto")
+      expect(isEnd).to eq(false)
+    end
+
+    it "Find simple situation of end." do
+      isEnd = @endBlock.has_end_of_block?("end")
+      expect(isEnd).to eq(true)
+    end
+
+    it "Find end of block with spaces in the begin." do
+      isEnd = @endBlock.has_end_of_block?("     end")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?(" end")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?("                             end")
+      expect(isEnd).to eq(true)
+    end
+
+    it "Find end of block with space after." do
+      isEnd = @endBlock.has_end_of_block?("end          ")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?("end ")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?("end               ")
+      expect(isEnd).to eq(true)
+    end
+
+    it "Find end of block with space in the begin and in the end." do
+      isEnd = @endBlock.has_end_of_block?("     end          ")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?("       end ")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?(" end    ")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?(" end ")
+      expect(isEnd).to eq(true)
+      isEnd = @endBlock.has_end_of_block?("     end     ")
+      expect(isEnd).to eq(true)
+    end
+
+  end
+
+  #context "end in the same line of other instructions" do
+  # TODO: This is the hardest cases. Do it!
+  #end
+
+  after :all do
+    @endBlock = nil
+  end
+
+end
+

data/spec/language/ruby/function_behavior_ruby_spec.rb

@@ -0,0 +1,246 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::FunctionBehaviorRuby do
+
+  before :all do
+    @functionBehaviorRuby = Languages::Ruby::FunctionBehaviorRuby.new
+  end
+
+  context "When method without parameters" do
+    it "Common declaration." do
+      input = "def xpto_method"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "With whitespace in the beginning." do
+      input = "   def xpto_method"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "With whitespace at the end." do
+      input = "def xpto_method "
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Between whitespace." do
+      input = "   def xpto_method "
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Whitespace between def and method name." do
+      input = "def  xpto_method"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Whitespace in the beginning and between def." do
+      input = "  def   xpto_method"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Whitespace between def and in the end." do
+      input = "def  xpto_method    "
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Tab in the beginning and space in the end." do
+      input = "     def  xpto_method "
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Whitespace in the beginning and in the end." do
+      input = "       def  xpto_method    "
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Many whitespace between def." do
+      input = "     def        xpto_method"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Whitespace in the beginning, between and in the end" do  
+      input = "  def   xpto_method   "
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+  end
+
+  context "With parameters" do
+    it "Take method name" do
+      input = "def xpto_method(a, b, c, d)\n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Whitespace in the beginning." do
+      input = "    def xpto_method(a, b, c, d)\n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Whitespace in the end." do
+      input = "def xpto_method(a, b, c, d)     \n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Between whitespace." do
+      input = "    def xpto_method(a, b, c, d)   \n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Spaces between parameters." do
+      input = "def xpto_method (a, b, c, d)\n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Many whitespace between method name and parameters." do
+      input = "  def xpto_method      (a, b, c, d)\n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Many whitespace between method declaration." do
+      input = "   def    xpto_method     (   a  , b  ,      c   ,     d   ) \n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+
+    it "Different whitespace patterns." do
+      input = "  def    xpto_method    (        a, b,    c, d )   \n"
+      expect(@functionBehaviorRuby.get_function(input).name)
+              .to eq("xpto_method")
+    end
+  end
+
+  context "When has parameters and parenthesis." do
+    it "One parameter" do
+      input = "def xpto_method(a)"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["a"])
+    end
+
+    it "Two parameters" do
+      input = "def xpto_method(a, b)"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["a", "b"])
+    end
+
+    it "Three parameters" do
+      input = "def xpto_method(a, ab, abc)"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["a", "ab", "abc"])
+    end
+
+    it "Three parameters, with whitespace." do
+      input = "def xpto_method (a, ab , abc)   "
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["a", "ab", "abc"])
+    end
+
+
+    it "One parameter with assignment" do
+      input = "def xpto_method(a=3)"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array([{"a"=>"3"}])
+    end
+
+    it "Two parameters with assignment" do
+      input = "def xpto_method(a=4, b=7)"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array([{"a"=>"4"}, {"b"=>"7"}])
+    end
+
+    it "Parameters with whitespace between them." do
+      input = "def xpto_method(a=7,               b=8, c =      0, d = 324)"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array([{"a"=>"7"}, {"b"=>"8"}, 
+                                                  {"c"=>"0"}, {"d"=>"324"}])
+    end
+
+    it "Parameters with whitespace between assignment." do
+      input = "def xpto_method(a        =  7,b =8, c  =  0,d    = 324)"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array([{"a"=>"7"}, {"b"=>"8"}, 
+                                                  {"c"=>"0"}, {"d"=>"324"}])
+
+    end
+
+    it "No parameter, just parenthesis" do
+      input = "def xpto_method()"
+
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to eq([])
+    end
+  end
+
+
+  context "When has parameters and no parenthesis." do
+    it "No parenthesis, and one parameter" do
+      input = "def xpto_method x"
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["x"])
+    end
+
+    it "One parameter, with space at the end." do
+      input = "def xpto_method x       "
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["x"])
+    end
+
+    it "One parameter, with space in the end and in the begining." do
+      input = "def xpto_method       x           "
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["x"])
+    end
+
+    it "One parameter, multiple spaces" do
+      input = "       def xpto_method       x         "
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["x"])
+    end
+
+    it "Two parameters" do
+      input = "def xpto_method x,y"
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["x", "y"])
+    end
+
+    it "Three parameters" do
+      input = "def xpto_method x, abcde, xyz"
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["x", "abcde", "xyz"])
+    end
+
+    it "Multiple parameters with many spaces" do
+      input = " def xpto_method     x ,    m,    nda ,       t  "
+      methodOne = @functionBehaviorRuby.get_function(input)
+      expect(methodOne.parameters).to match_array(["x", "m", "nda", "t"])
+    end
+
+  end
+
+  after :all do
+    @functionBehaviorRuby = nil
+  end
+
+end

data/spec/language/ruby/module_namespace_ruby_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::ModuleNamespaceRuby do
+
+  before :all do
+    @modules = Languages::Ruby::ModuleNamespaceRuby.new
+  end
+  
+  context "Common case of module declarations" do
+    it "Module on corner." do
+      capturedModule = @modules.get_module("module Abc")
+      expect(capturedModule.name).to eq("Abc")
+    end
+
+    it "Module with space before." do
+      capturedModule = @modules.get_module("     module Xpto")
+      expect(capturedModule.name).to eq("Xpto")
+    end
+
+    it "Module with space after." do
+      capturedModule = @modules.get_module("module TestOne       ")
+      expect(capturedModule.name).to eq("TestOne")
+    end
+
+    it "Module with space after, and before." do
+      capturedModule = @modules.get_module("     module BeforeAfter      ")
+      expect(capturedModule.name).to eq("BeforeAfter")
+    end
+
+    it "Module with space between keyword and name." do
+      capturedModule = @modules.get_module("module       SpaceBetween")
+      expect(capturedModule.name).to eq("SpaceBetween")
+    end
+
+    it "Module with space between keyword, and before." do
+      capturedModule = 
+        @modules.get_module("     module     SpaceBetweenBefore")
+      expect(capturedModule.name).to eq("SpaceBetweenBefore")
+    end
+
+    it "Module with space before keyword, and after." do
+      capturedModule = @modules.get_module("module    SpaceBetweenAfter      ")
+      expect(capturedModule.name).to eq("SpaceBetweenAfter")
+    end
+
+    it "Module with space before keyword, between, and after" do
+      capturedModule = @modules.get_module("     module  BeforeBetweenAfter  ")
+      expect(capturedModule.name).to eq("BeforeBetweenAfter")
+    end
+  end
+
+  after :all do
+    @module = nil
+  end
+end

data/spec/language/ruby/repetition_ruby_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../spec_helper'
+
+RSpec.describe Languages::Ruby::RepetitionRuby do
+
+  before :each do
+    @repetitionRuby = Languages::Ruby::RepetitionRuby.new
+  end
+
+  context "When it is if statment." do
+    it "Simple if statment." do
+      input = "while gets do"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq("gets")
+
+      input = "while 2 < 3 do"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq("2 < 3")
+
+      #input = "for x.range(0,1)"
+      #repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      #expect(repetitionCaptured).to eq("x.range(0,1)")
+
+      input = "while x == 222222 do"
+      repetitionCaptured = @repetitionRuby.get_repetition(input).expression
+      expect(repetitionCaptured).to eq("x == 222222")
+    end
+  end
+
+  after :each do
+    @repetitionRuby = nil
+  end
+
+end