kuniri 0.0.1 → 0.2

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

@@ -15,7 +15,6 @@ module StateMachine
 
       # @see OOStructuredState
       def handle_line(pLine)
-          # TODO: YOU HAVE TO HANDLER THE CASE OF SELF REFERENCE
       end
 
       # @see OOStructuredState

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

@@ -0,0 +1,182 @@
+require_relative 'oo_structured_state'
+require_relative '../../language/abstract_container/structured_and_oo/global_tokens.rb'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling Basic structures state. Understand basic
+    # basic structure by conditional and repetitions.
+    class BasicStructureState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+        @language.resetNested
+        @whoAmI = "the fu@!+ nobody"
+      end
+
+      def handle_line(pLine)
+        conditional = @language.conditionalHandler.get_conditional(pLine)
+        repetition = @language.repetitionHandler.get_repetition(pLine)
+        if conditional
+          if isNestedStructure?(conditional.type)
+            conditional_capture
+          end
+        elsif repetition
+          if isNestedStructure?(repetition.type)
+            repetition_capture
+          end
+        # aggregation
+        end
+      end
+
+      # @see OOStructuredState
+      def method_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def constructor_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def conditional_capture
+        @language.moreNested
+        @language.set_state(@language.conditionalState)
+      end
+
+      # @see OOStructuredState
+      def repetition_capture
+        @language.moreNested
+        @language.set_state(@language.repetitionState)
+      end
+
+      # @see OOStructuredState
+      def function_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def aggregation_capture
+        @language.set_state(@language.aggregationState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        flag = @language.flagFunctionBehaviour
+        classIndex = pElementFile.classes.length - 1 # We want the index
+
+        addBasicStructure(pLine, flag, classIndex, pElementFile)
+
+        #if (@language.endBlockHandler.has_end_of_block?(pLine) || singleLine)
+        if (@language.endBlockHandler.has_end_of_block?(pLine))
+          updateLevel(flag, pElementFile, classIndex)
+        end
+        return pElementFile
+      end
+
+      protected
+
+        @whoAmI # !@param whoAmI Used for differentiated child class.
+
+        # Add conditional or repetition. It is delegate to child class.
+        # @param pLine Line to analyse
+        # @param pFlag Flag for identify global function, constructor or method
+        # @param pClassIndex Element index to add
+        # @param pElementFile Element with all data
+        def addBasicStructure(pLine, pFlag, pClassIndex, pElementFile)
+          raise NotImplementedError
+        end
+
+        # If is a structure which can be nested. It is delegate.
+        # @param pType Constant with type description.
+        def isNestedStructure?(pType)
+          if pType == Languages::WHILE_LABEL ||
+              pType == Languages::FOR_LABEL ||
+              pType == Languages::DO_WHILE_LABEL ||
+              pType == Languages::UNTIL_LABEL ||
+              pType == Languages::IF_LABEL ||
+              pType == Languages::CASE_LABEL ||
+              pType == Languages::UNLESS_LABEL
+            return true
+          end
+          return false
+
+        end
+
+        # Add element to correct place, based on the state machine position.
+        # @pElement Specific element, e.g, conditional or repetition object.
+        # @pElementFile All data.
+        # @pFlag Flag with current position in the state machine.
+        # @pClassIndex Index of class.
+        def addToCorrectElement(pElement, pElementFile, pFlag, pClassIndex)
+          elementType = pElement.type
+          stringToEval = "classes[#{pClassIndex}]."
+          case pFlag
+            when StateMachine::GLOBAL_FUNCTION_STATE
+              dynamicallyAdd(pElementFile, pElement,
+                                    elementType, "global_functions")
+            when StateMachine::METHOD_STATE
+              dynamicallyAdd(pElementFile, pElement,
+                                    elementType, stringToEval + "methods")
+            when StateMachine::CONSTRUCTOR_STATE
+              dynamicallyAdd(pElementFile, pElement,
+                                elementType, stringToEval + "constructors")
+          end
+        end
+
+        # Update nested level in conditional or repetition.
+        # @param pFlag
+        # @param pElementFile
+        # @param pClassIndex
+        def updateLevel(pFlag, pElementFile, pClassIndex)
+          case pFlag
+            when StateMachine::GLOBAL_FUNCTION_STATE
+              dynamicLevelUpdate(pElementFile, "global_functions")
+            when StateMachine::METHOD_STATE
+              stringMethod = "classes[#{pClassIndex}].methods"
+              dynamicLevelUpdate(pElementFile, stringMethod)
+            when StateMachine::CONSTRUCTOR_STATE
+              stringMethod = "classes[#{pClassIndex}].constructors"
+              dynamicLevelUpdate(pElementFile, stringMethod)
+           end
+          @language.rewind_state
+          @language.lessNested
+        end
+
+        # Dynamically add based on child class.
+        # @param pElementFile All data inside element.
+        # @param pToAdd Element to add.
+        # @param pType Type of thhe element.
+        # @param pElement Element description.
+        def dynamicallyAdd(pElementFile, pToAdd, pType, pElement)
+          classIndex = pElementFile.classes.length - 1 # We want the index
+          index = eval("pElementFile.#{pElement}.length - 1")
+          if (@language.isNested? && isNestedStructure?(pType))
+            eval("pElementFile.#{pElement}[index]." +
+                  "managerCondAndLoop.down_level")
+          end
+          eval("pElementFile.#{pElement}[index].add_#{@whoAmI}(pToAdd)")
+        end
+
+        # Update level of conditional or repetition
+        # @param pElementFile Element with all data.
+        # @param pElement String name of the element.
+        def dynamicLevelUpdate(pElementFile, pElement)
+         index = eval("pElementFile.#{pElement}.length - 1")
+         if @language.isNested?
+           eval("pElementFile.#{pElement}[index].managerCondAndLoop.up_level")
+         end
+       end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

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

@@ -15,7 +15,9 @@ module StateMachine
 
       # @see OOStructuredState
       def handle_line(pLine)
-        if @language.attributeHandler.get_attribute(pLine)
+        if @language.aggregationHandler.get_aggregation(pLine)
+          aggregation_capture
+        elsif @language.attributeHandler.get_attribute(pLine)
           attribute_capture
         elsif @language.constructorHandler.get_constructor(pLine)
           constructor_capture
@@ -23,6 +25,8 @@ module StateMachine
           method_capture
         elsif @language.moduleHandler.get_module(pLine)
           module_capture
+        elsif @language.aggregationHandler.get_aggregation(pLine)
+          aggregation_capture
         elsif @language.commentHandler.is_single_line_comment?(pLine) ||
               @language.commentHandler.is_multiple_line_comment?(pLine)
           comment_capture
@@ -59,6 +63,10 @@ module StateMachine
         @language.set_state(@language.commentState)
       end
 
+      def aggregation_capture
+        @language.set_state(@language.aggregationState)
+      end
+
       # @see OOStructuredState
       def execute(pElementFile, pLine)
         classElement = @language.classHandler.get_class(pLine)
@@ -67,8 +75,9 @@ module StateMachine
           classElement.comments = @language.string_comment_to_transfer
           @language.string_comment_to_transfer = ""
           pElementFile.add_class(classElement)
+          @language.metadata.allClasses.push(classElement)
         end
- 
+
         if @language.endBlockHandler.has_end_of_block?(pLine)
           previous = @language.previousState.last
 
@@ -90,5 +99,5 @@ module StateMachine
   # End OOStructuredFSM
   end
 
-# 
+# End module
 end

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

@@ -1,87 +1,30 @@
-require_relative 'oo_structured_state'
+require_relative 'basic_structure_state'
+require_relative '../../language/abstract_container/structured_and_oo/global_tokens.rb'
 
 module StateMachine
 
   module OOStructuredFSM
 
-    # Class responsible for handling conditional state.
-    class ConditionalState < OOStructuredState
+    # Class responsible for handling Conditional state.
+    class ConditionalState < BasicStructureState
 
       @language
 
       def initialize(pLanguage)
         @language = pLanguage
+        @whoAmI = "conditional"
       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 add_conditional_element(pFlag, pElementFile, pConditional)
-        if pFlag == StateMachine::GLOBAL_FUNCTION_STATE
-          pElementFile.global_functions
-                  .last.add_conditional(pConditional)
-        elsif pFlag == StateMachine::METHOD_STATE
-          pElementFile.classes.last.methods
-                  .last.add_conditional(pConditional)
-        elsif pFlag == StateMachine::CONSTRUCTOR_STATE
-           pElementFile.classes.last.constructors
-                   .last.add_conditional(pConditional)
-        end
-          return pElementFile
-      end
+      protected
 
-      # @see OOStructuredState
-      def execute(pElementFile, pLine)
-        conditional = @language.conditionalHandler.get_conditional(pLine)
-
-        flag = @language.flagFunctionBehaviour
-
-        if (conditional)
-          pElementFile = add_conditional_element(flag,
-                                          pElementFile, conditional)
-        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
+        # @see basic_structure_state
+        def addBasicStructure(pLine, pFlag, pClassIndex, pElementFile)
+          conditional = @language.conditionalHandler.get_conditional(pLine)
+          if (conditional)
+            addToCorrectElement(conditional, pElementFile, pFlag, pClassIndex)
           end
         end
 
-        return pElementFile
-
-      end
-
-      private
-
-        # @see OOStructuredState
-        def reset_flag
-          @language.flagFunctionBehaviour = StateMachine::NONE_HANDLING_STATE
-        end
-
-    
     # End class
     end
 

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

@@ -1,66 +1,21 @@
 require_relative 'oo_structured_state'
+require_relative 'function_behaviour_state'
 
 module StateMachine
 
   module OOStructuredFSM
 
     # Class responsible for handling constructor state.
-    class ConstructorState < OOStructuredState
-
-      @language
+    class ConstructorState < FunctionBehaviourState
 
       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::CONSTRUCTOR_STATE
-        @language.set_state(@language.conditionalState)
+        super(
+          pLanguage,
+          flagState: StateMachine::CONSTRUCTOR_STATE,
+          functionId: StateMachine::CONSTRUCTOR_LABEL
+        )
       end
 
-      # @see OOStructuredState
-      def repetition_capture
-        @language.flagFunctionBehaviour = StateMachine::CONSTRUCTOR_STATE
-        @language.set_state(@language.repetitionState)
-      end
-
-      # @see OOStructuredState
-      def execute(pElementFile, pLine)
-        constructorElement =
-                          @language.constructorHandler.get_constructor(pLine)
-
-        if (constructorElement)
-          lastIndex = pElementFile.classes.length - 1 # We want the index
-          constructorElement.comments = @language.string_comment_to_transfer
-          @language.string_comment_to_transfer = ""
-          pElementFile.classes[lastIndex].add_constructor(constructorElement)
-        end
-
-        if (@language.endBlockHandler.has_end_of_block?(pLine))
-          class_capture
-        end
-
-        return pElementFile
-
-      end
-    
     # End class
     end
 

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

@@ -0,0 +1,86 @@
+require_relative 'oo_structured_state'
+require_relative 'token_state_machine'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling Method and constructor state.
+    class FunctionBehaviourState < OOStructuredState
+
+      @language
+      @flagState
+      @functionIdentifier
+
+      # Constructor responsible for setup the basic configuration.
+      # @param pLanguage Reference to language object.
+      # @param pParams Dictionary with all element data.
+      def initialize(pLanguage, pParams = {})
+        @language = pLanguage
+        @flagState = pParams[:flagState] || StateMachine::METHOD_STATE
+        @functionIdentifier = pParams[:functionId] || MethodState::METHOD_LABEL
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+        if @language.conditionalHandler.get_conditional(pLine)
+          conditional_capture
+        elsif @language.repetitionHandler.get_repetition(pLine)
+          repetition_capture
+        elsif @language.aggregationHandler.get_aggregation(pLine)
+          aggregation_capture
+        else
+          return
+        end
+      end
+
+      # @see OOStructuredState
+      def class_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def conditional_capture
+        @language.flagFunctionBehaviour = @flagState
+        @language.set_state(@language.conditionalState)
+      end
+
+      # @see OOStructuredState
+      def repetition_capture
+        @language.flagFunctionBehaviour = @flagState
+        @language.set_state(@language.repetitionState)
+      end
+
+      # @see OOStructuredState
+      def aggregation_capture
+        @language.set_state(@language.aggregationState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        functionElement = @language.send("#{@functionIdentifier}Handler")
+                                   .send("get_#{@functionIdentifier}", pLine)
+
+        if (functionElement)
+          lastIndex = pElementFile.classes.length - 1 # We want the index
+          functionElement.comments = @language.string_comment_to_transfer
+          @language.string_comment_to_transfer = ""
+          pElementFile.classes[lastIndex].send("add_#{@functionIdentifier}",
+                                               functionElement)
+        end
+
+        if (@language.endBlockHandler.has_end_of_block?(pLine))
+          @language.rewind_state
+        end
+
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end