kuniri 0.0.1

data/spec/state_machine/OO_structured_fsm/constructor_state_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::ConstructorState do
+
+  before :each do
+    @constructorTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow." do
+    it "Idle to constructor." do
+      @constructorTest.class_capture
+      @constructorTest.constructor_capture
+      expect(@constructorTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ConstructorState)
+    end
+
+    it "Constructor to class." do
+      @constructorTest.class_capture
+      @constructorTest.constructor_capture
+      @constructorTest.class_capture
+      expect(@constructorTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ClassState)
+    end
+
+    it "Constructor to idle." do
+      @constructorTest.class_capture
+      @constructorTest.constructor_capture
+      @constructorTest.class_capture
+      @constructorTest.idle_capture
+      expect(@constructorTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+  end
+
+  context "Incorrect flow." do
+    it "Try to access IdleState, from ConstructorState." do
+      @constructorTest.class_capture
+      @constructorTest.constructor_capture
+      expect{@constructorTest.idle_capture}
+        .to raise_error(NotImplementedError)
+    end
+  end
+
+  after :each do
+    @constructorTest = nil
+  end
+
+end

data/spec/state_machine/OO_structured_fsm/function_state_spec.rb

@@ -0,0 +1,41 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::FunctionState do
+
+  before :each do
+    @rubyTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow." do
+
+    it "Idle to function." do
+      @rubyTest.state.function_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::FunctionState)
+    end
+
+    it "Module to function" do
+      @rubyTest.state.module_capture
+      @rubyTest.state.function_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::FunctionState)
+    end
+  end
+
+  context "Incorrect flow." do
+    it "Function to variable" do
+      @rubyTest.state.function_capture
+      expect{@rubyTest.variable_capture}
+        .to raise_error(NotImplementedError)
+    end
+  end
+
+  context "Flow based of file." do
+
+  end
+
+  after :each do
+    @rubyTest = nil
+  end
+
+end

data/spec/state_machine/OO_structured_fsm/idle_state_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::IdleState do
+
+  before :each do
+    @rubyTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow." do
+
+    it "Idle to include." do
+      @rubyTest.include_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IncludeState)
+    end
+
+    it "Include to idle." do
+      @rubyTest.include_capture
+      @rubyTest.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+    it "Idle to variable." do
+      @rubyTest.variable_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::VariableState)
+    end
+
+    it "Variable to idle." do
+      @rubyTest.variable_capture
+      @rubyTest.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+    it "Idle to function." do
+      @rubyTest.function_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::FunctionState)
+    end
+
+    it "Function to idle." do
+      @rubyTest.function_capture
+      @rubyTest.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+    it "Idle to module." do
+      @rubyTest.module_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ModuleState)
+    end
+
+    it "Module to idle." do
+      @rubyTest.module_capture
+      @rubyTest.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+    it "Idle to class." do
+      @rubyTest.class_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ClassState)
+    end
+
+    it "Class to idle." do
+      @rubyTest.class_capture
+      @rubyTest.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+  end
+
+  context "Incorrect Flow" do
+
+    it "Idle to Method." do
+      expect{@rubyTest.method_capture}
+        .to raise_error(NotImplementedError)
+    end
+
+    it "Idle to Attribute" do
+      expect{@rubyTest.attribute_capture}
+        .to raise_error(NotImplementedError)
+    end
+
+    it "Idle to constructor" do
+      expect{@rubyTest.constructor_capture}
+        .to raise_error(NotImplementedError)
+    end
+
+  end
+
+  after :each do
+    @rubyTest = nil
+  end
+
+end

data/spec/state_machine/OO_structured_fsm/include_state_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::IncludeState do
+
+  before :each do
+    @rubyTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow." do
+
+    it "Idle to Include" do
+      @rubyTest.state.include_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IncludeState)
+    end
+
+    it "Include to idle" do
+      @rubyTest.state.include_capture
+      @rubyTest.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+  end
+
+  context "Incorrect flow." do
+
+    it "Include to variable" do
+      @rubyTest.state.include_capture
+      expect{@rubyTest.variable_capture}
+        .to raise_error(NotImplementedError)
+    end
+
+  end
+
+  context "Correct flow, and correct data extration." do
+
+    it "Include state, and capture require." do
+      @rubyTest.state.include_capture
+      fileElement = Languages::FileElement.new("test_spec")
+      @rubyTest.state.execute(fileElement, "require_relative 'test_file.rb'")
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+    it "Include state, and returned value" do
+      @rubyTest.state.include_capture
+      fileElement = Languages::FileElement.new("test_spec")
+      fileElement = @rubyTest.state.execute(fileElement,
+                                            "require_relative 'test.rb'")
+      expect(fileElement.extern_requirements[0].name).to eq ("test")
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+  end
+
+  after :each do
+    @rubyTest = nil
+  end
+
+end

data/spec/state_machine/OO_structured_fsm/method_state_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::MethodState do
+
+  before :each do
+    @rubyTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow." do
+
+    it "Idle to method" do
+      @rubyTest.class_capture
+      @rubyTest.method_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::MethodState)
+    end
+
+    it "Method to class" do
+      @rubyTest.class_capture
+      @rubyTest.method_capture
+      @rubyTest.class_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ClassState)
+    end
+
+  end
+
+  context "Incorrect flow." do
+
+    it "Method to idle" do
+      @rubyTest.class_capture
+      @rubyTest.method_capture
+      expect{@rubyTest.idle_capture}
+    end
+
+  end
+
+  after :each do
+    @rubyTest = nil
+  end
+
+end

data/spec/state_machine/OO_structured_fsm/module_state_spec.rb

@@ -0,0 +1,54 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::ModuleState do
+
+  before :each do
+    @rubyTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow." do
+
+    it "Idle to module" do
+      @rubyTest.state.module_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ModuleState)
+    end
+
+    it "Module to idle" do
+      @rubyTest.state.module_capture
+      @rubyTest.state.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+    it "Module to function" do
+      @rubyTest.state.module_capture
+      @rubyTest.state.function_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::FunctionState)
+    end
+
+    it "Module to class" do
+      @rubyTest.state.module_capture
+      @rubyTest.state.class_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ClassState)
+    end
+
+  end
+
+  context "Incorrect flow." do
+
+    it "Incorrect flow" do
+      @rubyTest.state.module_capture
+      expect{@rubyTest.method_capture}
+        .to raise_error(NotImplementedError)
+    end
+
+  end
+
+  after :each do
+    @rubyTest = nil
+  end
+
+end

data/spec/state_machine/OO_structured_fsm/repetition_state_spec.rb

@@ -0,0 +1,83 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::RepetitionState do
+
+  before :each do
+    @repetitionTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow, function." do
+    it "Idle to global function, to repetition." do
+      @repetitionTest.state.function_capture
+      @repetitionTest.state.repetition_capture
+      expect(@repetitionTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::RepetitionState)
+    end
+
+    it "Repetition to idle." do
+      @repetitionTest.state.function_capture
+      @repetitionTest.state.repetition_capture
+      @repetitionTest.state.function_capture
+      expect(@repetitionTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::FunctionState)
+    end
+  end
+
+  context "Correct flow, method." do
+    it "Idle to class, method, and repetition." do
+      @repetitionTest.state.class_capture
+      @repetitionTest.state.method_capture
+      @repetitionTest.state.repetition_capture
+      expect(@repetitionTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::RepetitionState)
+    end
+
+    it "Conditional to idle (method)." do
+      @repetitionTest.state.class_capture
+      @repetitionTest.state.method_capture
+      @repetitionTest.state.repetition_capture
+      @repetitionTest.state.method_capture
+      expect(@repetitionTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::MethodState)
+    end
+  end
+
+  context "Correct flow, constructor." do
+    it "Idle to constructor, and repetition." do
+      @repetitionTest.state.class_capture
+      @repetitionTest.state.constructor_capture
+      @repetitionTest.state.repetition_capture
+      expect(@repetitionTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::RepetitionState)
+    end
+
+    it "Repetition to idle (constructor)." do
+      @repetitionTest.state.class_capture
+      @repetitionTest.state.constructor_capture
+      @repetitionTest.state.repetition_capture
+      @repetitionTest.state.constructor_capture
+      expect(@repetitionTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::ConstructorState)
+    end
+  end
+
+  context "Incorrect flow." do
+    it "Try to access IdleState, to ConditionalState." do
+      expect{@repetitionTest.state.repetition_capture}
+        .to raise_error(NotImplementedError)
+    end
+
+    it "Try to jump from Conditional state to idle." do
+      @repetitionTest.state.class_capture
+      @repetitionTest.state.method_capture
+      @repetitionTest.state.repetition_capture
+      expect{@repetitionTest.state.class_capture}
+        .to raise_error(NotImplementedError)
+    end
+  end
+
+  after :each do
+    @constructorTest = nil
+  end
+
+end

data/spec/state_machine/OO_structured_fsm/variable_state_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../../spec_helper'
+
+RSpec.describe StateMachine::OOStructuredFSM::VariableState do
+
+  before :each do
+    @rubyTest = Languages::RubySyntax.new
+  end
+
+  context "Correct flow." do
+
+    it "Idle to variable." do
+      @rubyTest.variable_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::VariableState)
+    end
+
+    it "Variable to idle." do
+      @rubyTest.variable_capture
+      @rubyTest.idle_capture
+      expect(@rubyTest.state)
+        .to be_instance_of(StateMachine::OOStructuredFSM::IdleState)
+    end
+
+  end
+
+  context "Incorrect flow." do
+
+    it "Variable to module." do
+      @rubyTest.variable_capture
+      expect{@rubyTest.module_capture}
+        .to raise_error(NotImplementedError)
+    end
+
+  end
+
+  after :all do
+    @rubyTest = nil
+  end
+
+end

data/spec/util/html_logger_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper'
+
+RSpec.describe Util::HtmlLogger do
+  context "Write html log" do 
+    
+    before :all do
+      @html = Util::HtmlLogger.new("log.html")
+      @html.write_log("HTML log")
+    end
+
+    it "Create file" do 
+      expect(File.exists?("log.html")).to eq (true)
+    end
+
+    it "Write message" do
+      message = Array.new
+      File.open("log.html").each_line do |line|
+        if line.include?("<i>")
+          message = line
+        end
+      end
+      expect(message).to eq ("\t<i>HTML log</i>\n")
+    end
+
+    after :all do
+      File.delete("log.html")
+      @html = nil
+    end
+
+  end 
+end

data/spec/util/logger_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+
+RSpec.describe Util::Logger do
+    
+  before :all do
+    @abstractLogger = Util::Logger.new
+  end
+
+  context "Try to write." do
+    it "Try to access implemented error." do
+      expect{@abstractLogger.write_log("xpto")}.to raise_error(
+              NotImplementedError)
+    end
+  end 
+
+  after :all do
+    @abstractLogger = nil
+  end
+
+end

data/spec/util/txt_logger_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper'
+
+RSpec.describe Util::TxtLogger do
+  context "Write txt log" do
+
+    before :all do
+      @txt = Util::TxtLogger.new("kuniri_log.txt")
+      @txt.write_log("Text file log")
+    end
+
+    it "Create file" do
+      expect(File.exists?("kuniri_log.txt")).to eq (true)
+    end
+
+    it "Write message" do
+      message = Array.new
+      File.open("kuniri_log.txt").each_line do |line|
+        if line.include?("message:")
+          message = line.split(':')
+        end
+      end
+      expect(message[1]).to eq (" Text file log\n")
+    end
+
+    after :all do
+      File.delete("kuniri_log.txt")
+      @txt = nil
+    end
+
+  end
+end