kuniri 0.0.1

data/lib/kuniri/parser/parser.rb

@@ -0,0 +1,45 @@
+require_relative '../language/language_factory'
+require_relative '../util/html_logger'
+require_relative '../util/html_logger'
+
+# Module responsible for keeping the parser handler
+module Parser
+
+  # Keep the relationship between languages and project
+  class Parser
+
+      public
+
+        attr_accessor :language
+        attr_reader :fileLanguage
+
+        def initialize(pFilesPath, pLanguage = "ruby")
+          @filesPath = pFilesPath
+          @fileLanguage = []
+          @log = @settings = Kuniri::Setting.create.log
+          @factory = Languages::LanguageFactory.new
+          @language = pLanguage
+        end
+
+        # Start parse in the project.
+        def start_parser
+          # TODO: handle the case of filePAth is empty
+          @log.write_log("Debug: START FIRST PARSER")
+          @filesPath.each do |file|
+            language = @factory.get_language(@language)
+            language.analyse_source(file)
+            @fileLanguage.push(language)
+          end
+        end
+
+      private
+
+        @filesPath
+        @log
+        @factory
+
+  # class
+  end
+
+# module
+end

data/lib/kuniri/parser/parser_xml.rb

@@ -0,0 +1,128 @@
+require 'nokogiri'
+require_relative '../language/container_data/structured_and_oo/class_data'
+
+module Parser
+
+  # Class responsible for generate xml output
+  class XML
+
+    def initialize(path = "kuniri.xml")
+      @log = @settings = Kuniri::Setting.create.log
+      set_path(path)
+    end
+
+    # Set path to save the output.
+    # @param pPath Output path.
+    def set_path(pPath)
+      @parser_path = pPath
+    end
+
+    # Create the xml output file, only saves a single ClassData for now
+    # @param class_data [ClassData] Receives the ClassData to save
+    def create_class_data(class_data)
+      @log.write_log("---- PARSER XML ----")
+      builder = Nokogiri::XML::Builder.new do |xml|
+        generate_class(xml, class_data)
+      end
+
+      @builder = builder
+
+      File.open(@parser_path, 'w') do |file|
+        file.write(builder.to_xml)
+      end
+    end
+
+    # Create the xml output file, only saves a ClassData for now.
+    # @param parser - Receives the parser
+    def create_all_data(parser)
+      @log.write_log("---- PARSER XML ----")
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.kuniri {
+          for elements in parser.fileLanguage do
+            if(elements.fileElements[0].classes.length() > 0)
+              generate_class(xml, elements.fileElements[0].classes[0])
+            end
+          end
+        }
+      end
+
+      @builder = builder
+
+      File.open(@parser_path, 'w') do |file|
+        file.write(builder.to_xml)
+      end
+    end
+
+    # returns the builder if create method already executed
+    def get_builder
+      @builder
+    end
+
+    # Parse a ClassData to xml
+    # @param xml [Nokogiri::XML::Builder] xml builder to edit
+    # @param class_data [ClassData] the ClassData to save
+    def generate_class(xml, class_data)
+      @log.write_log(class_data.name)
+      xml.class_data(:name => class_data.name) {
+        class_data.methods.each do |o|
+          generate_method(xml, o)
+        end
+        class_data.constructors.each do |c|
+          generate_constructor(xml, c)
+        end
+        class_data.inheritances.each do |i|
+          generate_inheritance(xml, i)
+        end
+      }
+    end
+
+    # Parse a InheritanceData to xml
+    # @param xml builder to edit
+    # @param inheritance_data the InheritanceData to save
+    def generate_inheritance(xml, inheritance_data)
+      xml.inheritance(:name => inheritance_data[0].strip()) {}
+    end
+
+    # Parse a ConstructorData to xml
+    # @param xml xml builder to edit
+    # @param constructor_data the ConstructorData to save
+    def generate_constructor(xml, constructor_data)
+      xml.method_(:name => constructor_data.name) {
+        constructor_data.parameters.each do |p|
+          generate_parameter(xml, p)
+        end
+      }
+    end
+
+    # Parse a MethodData to xml
+    # @param xml builder to edit
+    # @param method_data the MethodData to save
+    def generate_method(xml, method_data)
+      xml.method_(:name => method_data.name, :visibility => method_data.visibility) {
+        method_data.parameters.each do |p|
+          generate_parameter(xml, p)
+        end
+      }
+    end
+
+    # Parse a MethodData to xml
+    # @param xml builder to edit
+    # @param parameter the Attribute to save
+    def generate_parameter(xml, parameter)
+      if parameter.kind_of?(String)
+        xml.parameter(:name => parameter) {}
+      else
+        # Is a hash parameter=>defaultValue
+        for p in parameter do
+          xml.parameter(:name => p[0]+'='+p[1]) {}
+        end
+      end
+    end
+
+    private
+
+    @log
+
+  end
+end

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

@@ -0,0 +1,51 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling attribute state.
+    class AttributeState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+          # TODO: YOU HAVE TO HANDLER THE CASE OF SELF REFERENCE
+      end
+
+      # @see OOStructuredState
+      def class_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        attributeElement = @language.attributeHandler.get_attribute(pLine)
+
+        if attributeElement
+          # Add attribute to the last class
+          lastIndex = pElementFile.classes.length - 1 # We want the index
+          attributeElement.each do |attribute|
+            attribute.comments = @language.string_comment_to_transfer
+          end
+          @language.string_comment_to_transfer = ""
+          pElementFile.classes[lastIndex].add_attribute(attributeElement)
+        end
+
+        class_capture
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

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

@@ -0,0 +1,94 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling class state.
+    class ClassState < OOStructuredState
+
+      @language
+
+      def initialize (pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+        if @language.attributeHandler.get_attribute(pLine)
+          attribute_capture
+        elsif @language.constructorHandler.get_constructor(pLine)
+          constructor_capture
+        elsif @language.methodHandler.get_function(pLine)
+          method_capture
+        elsif @language.moduleHandler.get_module(pLine)
+          module_capture
+        elsif @language.commentHandler.is_single_line_comment?(pLine) ||
+              @language.commentHandler.is_multiple_line_comment?(pLine)
+          comment_capture
+        end
+      end
+
+      # @see OOStructuredState
+      def method_capture
+        @language.set_state(@language.methodState)
+      end
+
+      # @see OOStructuredState
+      def constructor_capture
+        @language.set_state(@language.constructorState)
+      end
+
+      # @see OOStructuredState
+      def attribute_capture
+        @language.set_state(@language.attributeState)
+      end
+
+      # @see OOStructuredState
+      def module_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def idle_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def comment_capture
+        @language.set_state(@language.commentState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        classElement = @language.classHandler.get_class(pLine)
+
+        if classElement
+          classElement.comments = @language.string_comment_to_transfer
+          @language.string_comment_to_transfer = ""
+          pElementFile.add_class(classElement)
+        end
+ 
+        if @language.endBlockHandler.has_end_of_block?(pLine)
+          previous = @language.previousState.last
+
+          if (previous.is_a? (StateMachine::OOStructuredFSM::IdleState))
+            idle_capture
+          elsif (previous.is_a? (StateMachine::OOStructuredFSM::ModuleState))
+            module_capture
+          else
+            return pElementFile
+          end
+        end
+
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# 
+end

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

@@ -0,0 +1,76 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # CommentState is responsible for handling comments.
+    class CommentState < OOStructuredState
+
+      @language
+      @multipleLineComment
+      @enableMultipleLine
+
+      def initialize(pLanguage)
+        @language = pLanguage
+        @multipleLineComment = ""
+        @enableMultipleLine = false
+      end
+
+      def handle_line(pLine)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        # Single line
+        if @language.commentHandler.is_single_line_comment?(pLine)
+          handling_single_line(pLine)
+          return pElementFile
+        end
+
+        # Multiple line
+        if @language.commentHandler.is_multiple_line_comment?(pLine)
+          @enableMultipleLine = true
+        end
+
+        if @language.commentHandler.is_multiple_line_comment_end?(pLine)
+          handling_multiple_line
+        end
+
+        if @enableMultipleLine
+          capture_multiple_line_comment(pLine)
+        end
+ 
+        return pElementFile
+
+      end
+
+      private
+
+        def handling_single_line(pLine)
+          comment_string = @language.commentHandler.get_comment(pLine)
+          comment_string += "\n"
+          @language.string_comment_to_transfer += comment_string
+          @language.rewind_state
+        end
+
+        def handling_multiple_line
+          @enableMultipleLine = false
+          @language.string_comment_to_transfer = @multipleLineComment
+          @multipleLineComment = ""
+          @language.rewind_state
+        end
+
+        def capture_multiple_line_comment(pLine)
+          comment_string = @language.commentHandler.get_comment(pLine)
+          @multipleLineComment += comment_string
+        end
+
+    # class
+    end
+
+  # module
+  end
+
+# module
+end

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

@@ -0,0 +1,92 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling conditional state.
+    class ConditionalState < 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 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
+
+      # @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
+          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/constructor_state.rb

@@ -0,0 +1,71 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling constructor state.
+    class ConstructorState < 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::CONSTRUCTOR_STATE
+        @language.set_state(@language.conditionalState)
+      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
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end

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

@@ -0,0 +1,82 @@
+require_relative 'oo_structured_state'
+require_relative 'module_state'
+require_relative 'token_state_machine'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling function state.
+    class FunctionState < 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 idle_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def module_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def conditional_capture
+        @language.flagFunctionBehaviour = StateMachine::GLOBAL_FUNCTION_STATE
+        @language.set_state(@language.conditionalState)
+      end
+
+      # @see OOStructuredState
+      def repetition_capture
+        @language.flagFunctionBehaviour = StateMachine::GLOBAL_FUNCTION_STATE
+        @language.set_state(@language.repetitionState)
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        function = @language.functionHandler.get_function(pLine)
+
+        if function
+          function.comments = @language.string_comment_to_transfer
+          @language.string_comment_to_transfer = ""
+          pElementFile.add_global_function(function)
+        end
+
+        if (@language.endBlockHandler.has_end_of_block?(pLine))
+          previous = @language.previousState.last
+
+          if (previous.is_a? (StateMachine::OOStructuredFSM::ModuleState))
+            module_capture
+          elsif (previous.is_a? (StateMachine::OOStructuredFSM::IdleState))
+            idle_capture
+          end
+
+        end
+
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end