kuniri 0.0.1

data/lib/kuniri/state_machine/OO_structured_fsm/idle_state.rb

@@ -0,0 +1,80 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling Idle state.
+    class IdleState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+        if @language.externRequirementHandler.get_requirement(pLine)
+          include_capture
+        elsif @language.variableHandler.get_variable(pLine)
+          variable_capture
+        elsif @language.functionHandler.get_function(pLine)
+          function_capture
+        elsif @language.moduleHandler.get_module(pLine)
+          module_capture
+        elsif @language.classHandler.get_class(pLine)
+          class_capture
+        elsif ((@language.commentHandler.is_single_line_comment?(pLine)) || 
+                (@language.commentHandler.is_multiple_line_comment?(pLine)))
+          comment_capture
+        else
+          return
+        end
+      end
+
+      # @see OOStructuredState
+      def include_capture
+        @language.set_state(@language.includeState)
+      end
+
+      # @see OOStructuredState
+      def variable_capture
+        @language.set_state(@language.variableState)
+      end
+
+      # @see OOStructuredState
+      def function_capture
+        @language.set_state(@language.functionState)
+      end
+
+      # @see OOStructuredState
+      def module_capture
+        @language.set_state(@language.moduleState)
+      end
+
+      # @see OOStructuredState
+      def class_capture
+        @language.set_state(@language.classState)
+      end
+
+      # @see OOStructuredState
+      def comment_capture
+        @language.set_state(@language.commentState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+
+        # Having nothing to do
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

data/lib/kuniri/state_machine/OO_structured_fsm/include_state.rb

@@ -0,0 +1,59 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling Include state.
+    class IncludeState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+        idle_capture
+        # TODO: HANDLING MULTIPLE LINE COMMENT.
+        #if @language.idleHandler.get_idle(pLine)
+        #  idle_capture
+        #else
+        # TODO: SAME STATE.
+        #end
+      end
+
+      # @see OOStructuredState
+      def idle_capture
+        @language.set_state(@language.idleState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+
+        requirement = @language.externRequirementHandler.get_requirement(pLine)
+
+        if requirement 
+         pElementFile.add_extern_requirement(requirement)
+        end
+
+        # TODO: You have to handler the return state.
+        idle_capture
+
+        if (@language.state.is_a? StateMachine::OOStructuredFSM::IdleState)
+          pElementFile.comments = @language.string_comment_to_transfer
+          @language.string_comment_to_transfer = ""
+        end
+
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

data/lib/kuniri/state_machine/OO_structured_fsm/method_state.rb

@@ -0,0 +1,69 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling Method state.
+    class MethodState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+        if @language.conditionalHandler.get_conditional(pLine)
+          conditional_capture
+        elsif @language.repetitionHandler.get_repetition(pLine)
+          repetition_capture
+        else
+          return
+        end
+      end
+
+      # @see OOStructuredState
+      def class_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def conditional_capture
+        @language.flagFunctionBehaviour = StateMachine::METHOD_STATE
+        @language.set_state(@language.conditionalState)
+      end
+
+      # @see OOStructuredState
+      def repetition_capture
+        @language.flagFunctionBehaviour = StateMachine::METHOD_STATE
+        @language.set_state(@language.repetitionState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        methodElement = @language.methodHandler.get_function(pLine)
+
+        if (methodElement)
+          lastIndex = pElementFile.classes.length - 1 # We want the index
+          methodElement.comments = @language.string_comment_to_transfer
+          @language.string_comment_to_transfer = ""
+          pElementFile.classes[lastIndex].add_method(methodElement)
+        end
+
+        if (@language.endBlockHandler.has_end_of_block?(pLine))
+          class_capture
+        end
+
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

data/lib/kuniri/state_machine/OO_structured_fsm/module_state.rb

@@ -0,0 +1,79 @@
+require_relative 'oo_structured_state'
+require_relative 'function_state'
+require_relative 'class_state'
+require_relative 'idle_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling Module state.
+    class ModuleState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+        if @language.classHandler.get_class(pLine)
+          class_capture
+        elsif @language.functionHandler.get_function(pLine)
+          function_capture
+        elsif @language.variableHandler.get_variable(pLine)
+          variable_capture
+        end
+      end
+
+      # @see OOStructuredState
+      def idle_capture
+        @language.set_state(@language.idleState)
+      end
+
+      # @see OOStructuredState
+      def class_capture
+        @language.set_state(@language.classState)
+      end
+
+      # @see OOStructuredState
+      def variable_capture
+        @language.set_state(@language.variableState)
+      end
+
+      # @see OOStructuredState
+      def function_capture
+        @language.set_state(@language.functionState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+
+        moduleElement = @language.moduleHandler.get_module(pLine)
+
+        if moduleElement
+          pElementFile.add_modules(moduleElement)
+        end
+
+        if @language.endBlockHandler.has_end_of_block?(pLine)
+          previous = @language.previousState.last
+
+          if (previous.is_a?(StateMachine::OOStructuredFSM::IdleState))
+            idle_capture
+          else
+            return pElementFile
+          end
+        end
+
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

data/lib/kuniri/state_machine/OO_structured_fsm/oo_structured_state.rb

@@ -0,0 +1,92 @@
+# Responsible for keep different state machines.
+module StateMachine
+
+  # Responsible for handling oriented object and structured paradigm.
+  module OOStructuredFSM
+
+    # @abstract State machine for oriented object and structured paradigm.
+    class OOStructuredState
+
+      # Method responsible each line, and decide which way to go inside state
+      # machine.
+      def handle_line(pLine)
+        raise NotImplementedError
+      end
+
+      # Handling class state, i.e, this state is enable when any class is match
+      def class_capture
+        raise NotImplementedError
+      end
+
+      # Handling method state, this state is enable only after class state.
+      def method_capture
+        raise NotImplementedError
+      end
+
+      # Handling constructor, only after class state.
+      def constructor_capture
+        raise NotImplementedError
+      end
+
+      # Handling attribute state.
+      def attribute_capture
+        raise NotImplementedError
+      end
+
+      # Handling module, it can be oriented object or structured.
+      def module_capture
+        raise NotImplementedError
+      end
+
+      # Handling function, it is related with structured state
+      # but not exclusively.
+      def function_capture
+        raise NotImplementedError
+      end
+
+      # Handling external include
+      def include_capture
+        raise NotImplementedError
+      end
+
+      # Handling variable
+      def variable_capture
+        raise NotImplementedError
+      end
+
+      # Idle state, waiting for action! =D
+      def idle_capture
+        raise NotImplementedError
+      end
+
+      # Handling conditional state
+      def conditional_capture
+        raise NotImplementedError
+      end
+
+      # Handling conditional state
+      def repetition_capture
+        raise NotImplementedError
+      end
+
+      # Handling comment
+      def comment_capture
+        raise NotImplementedError
+      end
+
+      # Method responsible for make the state machine go forward.
+      # @param pElementFile File to be improved.
+      # @param pLine Line for verify element.
+      # @return Return pElementFile with new elements, or with the same values.
+      def execute(pElementFile, pLine)
+        raise NotImplementedError
+      end
+
+    # End class
+    end
+
+  # End OOStructuredState
+  end
+
+# End StateMachine
+end

data/lib/kuniri/state_machine/OO_structured_fsm/repetition_state.rb

@@ -0,0 +1,85 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling Repetition state.
+    class RepetitionState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+        def handle_line(pLine)
+        end
+
+      # @see OOStructuredState
+      def method_capture
+        reset_flag
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def constructor_capture
+        reset_flag
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def function_capture
+        reset_flag
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        repetition = @language.repetitionHandler.get_repetition(pLine)
+
+        flag = @language.flagFunctionBehaviour
+
+        if (repetition)
+          #Function
+          if (flag == StateMachine::GLOBAL_FUNCTION_STATE)
+            pElementFile.global_functions.last.add_repetition(repetition)
+          #Method
+          elsif (flag == StateMachine::METHOD_STATE)
+            pElementFile.classes.last.methods.last.add_repetition(repetition)
+          #Constructor
+          elsif (flag == StateMachine::CONSTRUCTOR_STATE)
+            pElementFile.classes.last.constructors
+                        .last.add_repetition(repetition)
+          end
+        end
+
+        if (@language.endBlockHandler.has_end_of_block?(pLine))
+          if (flag == StateMachine::GLOBAL_FUNCTION_STATE)
+            function_capture
+          elsif (flag == StateMachine::METHOD_STATE)
+            method_capture
+          elsif (flag == StateMachine::CONSTRUCTOR_STATE)
+            constructor_capture
+          end
+        end
+
+        return pElementFile
+
+      end
+
+      private
+
+        # @see OOStructuredState
+        def reset_flag
+          @language.flagFunctionBehaviour = StateMachine::NONE_HANDLING_STATE
+        end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

data/lib/kuniri/state_machine/OO_structured_fsm/token_state_machine.rb

@@ -0,0 +1,8 @@
+module StateMachine
+
+  NONE_HANDLING_STATE       ||= -1      # NONE state, just for controlling. 
+  GLOBAL_FUNCTION_STATE     ||= 1       # Global state track.
+  CONSTRUCTOR_STATE         ||= 2       # Constructor state track.
+  METHOD_STATE              ||= 3       # Method state track.
+
+end

data/lib/kuniri/state_machine/OO_structured_fsm/variable_state.rb

@@ -0,0 +1,49 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Handling variable state.
+    class VariableState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+        idle_capture
+      end
+
+      # @see OOStructuredState
+      def idle_capture
+        @language.set_state(@language.idleState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        variableList = @language.variableHandler.get_variable(pLine)
+        if variableList
+          variableList.each do |variable|
+            variable.comments = @language.string_comment_to_transfer
+          end
+          @language.string_comment_to_transfer = ""
+          pElementFile.add_global_variable(variableList)
+        end
+
+        # TODO: You have to handler the return state.
+        idle_capture
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

data/lib/kuniri/util/html_logger.rb

@@ -0,0 +1,41 @@
+require_relative 'logger'
+
+module Util
+
+  # Handling HTML log.
+  class HtmlLogger < Logger
+
+    public
+
+      # @param pPath [String] Receives the path to save the log.
+      def initialize(pPath = "/tmp/kuniri_log.html")
+        super(pPath)
+        initialize_html_file
+      end
+
+      # @param pMessage [String] Log message to be write as .html
+      # documentation.
+      def write_log(pMessage)
+        File.open(@log_path, 'a') do |file|
+          file.write("<hr>\n")
+          file.write("<p>" + Time.now.strftime("%d/%m/%Y %H:%M:%S") + "</p>\n")
+          file.write("\t<i>#{pMessage}</i>\n")
+        end
+      end
+
+    private
+
+      def initialize_html_file
+        File.open(@log_path, 'a') do |file|
+          file.write("<html>\n")
+          file.write("\t<title>Kuniri log</title>\n\n")
+          #file.write("<body>\n")
+          #file.write("</body>\n")
+        end
+      end
+
+  # Class
+  end
+
+# Util
+end

data/lib/kuniri/util/logger.rb

@@ -0,0 +1,34 @@
+# Util provides classes, functions and constants which can be used for the
+# entire system.
+module Util
+
+  # Abstract class responsible for define the log strategy.
+  class Logger
+
+    # Create/open the log file, and save the path.
+    # @param pPath [String] Receives the path for save the log file. By default
+    #   it is saved on /tmp with the name "kuniri".
+    def initialize(pPath = "/tmp/kuniri.log")
+      File.open(pPath, 'a')
+      @log_path = pPath
+    end
+
+    public
+
+      # Write log, based on the message and the path. The most important thing
+      # about this method, is related with the implementation in different
+      # formats. Ex.: write_log can be implemented as HTML, txt, XML, etc.
+      # @param pMessage to write in the log file.
+      def write_log(pMessage)
+        raise NotImplementedError
+      end
+
+    protected
+
+      @log_path # Saved path of the log file.
+
+  # Class
+  end
+
+# Util
+end

data/lib/kuniri/util/txt_logger.rb

@@ -0,0 +1,29 @@
+require 'date'
+require_relative 'logger'
+
+module Util
+
+  # Create log in a text format. This classes handling the correct way of
+  # generate the log in a .txt format.
+  class TxtLogger < Util::Logger
+
+    # @param pPath [String] Path for save the log. The default is /tmp/
+    def initialize(pPath = "/tmp/kuniri.log")
+      super(pPath)
+    end
+
+    # Write a message as .txt file.
+    # @param pMessage [String] Massage to be write in the log file.
+    def write_log(pMessage)
+      File.open(@log_path, 'a') do |file|
+        file.write("="*10 + "\n")
+        file.write("time: " + Time.now.strftime("%d/%m/%Y %H:%M:%S") + "\n")
+        file.write("message: " + pMessage + "\n")
+      end
+    end
+
+  # Class
+  end
+
+# Util
+end 

data/lib/kuniri/version.rb

@@ -0,0 +1,3 @@
+module Kuniri
+  VERSION = "0.0.1"
+end

data/lib/kuniri.rb

@@ -0,0 +1,5 @@
+require "kuniri/version"
+
+module Kuniri
+  # Your code goes here...
+end

data/spec/core/kuniri_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../spec_helper'
+
+RSpec.describe Kuniri::Kuniri do
+
+  context "When path for run_analysis is wrong." do
+    it "Wrong path to " do
+      @kuniriTest = Kuniri::Kuniri.new("wrong/path")
+      defaultPath = @kuniriTest.run_analysis
+      folderFiles = Dir[File.join("./", "**", "**.rb")]
+      expect(defaultPath).to match_array(folderFiles)
+    end
+  end
+
+end