kuniri 0.0.1 → 0.2

data/lib/kuniri/parser/output_factory.rb

@@ -0,0 +1,29 @@
+require_relative '../error/language_error'
+require_relative 'xml_output_format'
+
+module Parser
+
+  # Simple factory to create output objects.
+  class OutputFactory
+
+    public
+
+      # Handling the output tyoe.
+      # @param pType [String] Type of object
+      # @return Return an object of output.
+      def get_output(pType)
+        pType.downcase!
+
+        if pType == "xml"
+          return XMLOutputFormat.new
+        end
+        if pType == "yml"
+          raise Error::ParserError
+        end
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/parser/output_format.rb

@@ -0,0 +1,134 @@
+require 'fileutils'
+
+require_relative '../core/setting'
+
+module Parser
+
+  class OutputFormat
+
+    public
+
+      attr_accessor :outputEngine
+      attr_accessor :parserPath
+      attr_accessor :extension
+
+      # Set path to save the output.
+      # @param pPath Output path.
+      def set_path(pPath)
+        @parserPath = pPath
+      end
+
+      # Go through all the data, and generate the output
+      # @param pParser
+      # @return
+      def create_all_data(pParser)
+        return nil unless pParser
+
+        saveElementTo = "./"
+        wrapper = self
+
+        # Go through each file
+        pParser.fileLanguage.each do |listOfFile|
+          # Inspect each element
+          listOfFile.fileElements.each do |singleElement|
+            @outputEngine.kuniri do
+              if (singleElement.extern_requirements.length() > 0)
+                wrapper.extern_requirement_generate(
+                        singleElement.extern_requirements)
+              end
+              if (singleElement.modules.length() > 0)
+                wrapper.module_generate(singleElement.modules)
+              end
+              #if (singleElement.global_variables.length() > 0)
+              #  wrapper.global_variable_generate(
+              #          singleElement.global_variables)
+              #end
+              if (singleElement.global_functions.length() > 0)
+                singleElement.global_functions.each do |globalFunction|
+                  wrapper.function_behaviour_generate("functionData",
+                                                      globalFunction)
+                end
+              end
+              if (singleElement.classes.length() > 0)
+                wrapper.class_generate(singleElement.classes)
+              end
+            end
+            saveElementTo = singleElement.name
+          end
+
+          write_file(saveElementTo, listOfFile.name)
+          @outputEngine.reset_engine
+        end
+
+      end
+
+      def class_generate(pClass)
+        raise NotImplementedError
+      end
+
+      def inheritance_generate(pInheritance)
+        raise NotImplementedError
+      end
+
+      def parameters_generate(pParameters)
+        raise NotImplementedError
+      end
+
+      def attribute_generate(pAttribute)
+        raise NotImplementedError
+      end
+
+      def function_behaviour_generate(pElementName, pFunction)
+        raise NotImplementedError
+      end
+
+      def global_variable_generate(pGlobalVariable)
+        raise NotImplementedError
+      end
+
+      def extern_requirement_generate(pRequire)
+        raise NotImplementedError
+      end
+
+      def basic_structure_generate(pManager)
+        raise NotImplementedError
+      end
+
+      def module_generate(pModule)
+        raise NotImplementedError
+      end
+
+      def comment_generate(pComment)
+        raise NotImplementedError
+      end
+
+      def aggregation_generate(pAggregation)
+        raise NotImplementedError
+      end
+
+    private
+
+      def write_file(pSaveTo, pFileName)
+        info = Kuniri::Setting.create
+        unless File.file?(info.configurationInfo[:source])
+          outputDir = File.join(@parserPath, File.dirname(pSaveTo))
+          unless Dir.exists? outputDir
+            FileUtils.mkdir_p(File.join(@parserPath,
+                                        File.dirname(pSaveTo)))
+          end
+          # TODO: Extension should be flexible
+          destination = File.join(outputDir, pFileName + ".xml")
+        else
+          destination = @parserPath
+        end
+
+        File.open(destination, "w") do |file|
+          file.write(@outputEngine.to_xml)
+        end
+      end
+
+  # class
+  end
+
+# module
+end

data/lib/kuniri/parser/parser.rb

@@ -1,6 +1,4 @@
 require_relative '../language/language_factory'
-require_relative '../util/html_logger'
-require_relative '../util/html_logger'
 
 # Module responsible for keeping the parser handler
 module Parser
@@ -12,19 +10,19 @@ module Parser
 
         attr_accessor :language
         attr_reader :fileLanguage
+        attr_reader :filesPath
 
         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")
+          raise Error::ConfigurationFileError if(@filesPath.empty?)
+
           @filesPath.each do |file|
             language = @factory.get_language(@language)
             language.analyse_source(file)
@@ -34,8 +32,6 @@ module Parser
 
       private
 
-        @filesPath
-        @log
         @factory
 
   # class

data/lib/kuniri/parser/xml_builder_engine.rb

@@ -0,0 +1,94 @@
+module Parser
+
+  class XMLBuilderEngine
+
+    attr_reader :tag
+    attr_reader :betweenTag
+    attr_reader :ident
+    attr_accessor :identIncrement
+
+    public
+
+      def initialize(pBaseSpaceIdent = 2)
+        set_default(pBaseSpaceIdent)
+      end
+
+      def to_xml
+        return @tag
+      end
+
+      def reset_engine
+        @tag = nil
+        set_default
+      end
+
+      def set_default(pBaseSpaceIdent = 2)
+        @tag = '<?xml version="1.0" encoding="UTF-8"?>'
+        @baseSpaceIdentation = pBaseSpaceIdent
+        @content = ''
+        @ident = ''
+        @identIncrement = ' ' * pBaseSpaceIdent
+      end
+
+    private
+
+      def method_missing(pTagName, *pTagParameters, &pBlock)
+        @tag += "\n" unless @tag.strip == ''
+        currentTagName = "#{@ident}<#{pTagName.to_s}"
+        @tag << currentTagName
+        if pTagParameters.size > 0 and pTagParameters[0].is_a? Hash
+          handleArguments(pTagParameters)
+        end
+
+        if block_given?
+          @tag << ">\n"
+          incrementIdentation
+          result = instance_eval(&pBlock)
+          if result != '' && result.is_a?(String)
+            updateTag(result)
+          end
+
+          decrementIdent
+          @tag << "#{@ident}</#{pTagName.to_s}>\n"
+          @tag.squeeze!("\n")
+        else
+          @tag << "/>\n"
+        end
+          @content = ''
+      end
+
+      def updateTag(pNewContent)
+        @content = "\n#{@ident}" + pNewContent + "\n"
+        @tag << @content
+      end
+
+      def handleArguments(pTagParameters)
+        pTagParameters[0].each do |key, value|
+          stringValue = handleSpecialCharactersXml(value.to_s)
+          @tag << " #{key.to_s}=\"#{stringValue}\""
+        end
+      end
+
+      def handleSpecialCharactersXml(pString)
+        if pString.count('"') > 0 || pString.count("&") > 0 ||
+            pString.count('>') > 0 || pString.count('<') > 0
+            pString = pString.gsub('"', "'")
+                              .gsub('&', '&amp;')
+                              .gsub('>', '&gt;')
+                              .gsub('<', '&lt;')
+          end
+        return pString
+      end
+
+      def incrementIdentation
+        @ident += @identIncrement
+      end
+
+      def decrementIdent
+        if @ident.size > 0
+          @ident = @ident[0...(@ident.size - @baseSpaceIdentation)]
+        end
+      end
+
+  end
+end

data/lib/kuniri/parser/xml_output_format.rb

@@ -0,0 +1,143 @@
+require_relative 'output_format'
+require_relative 'xml_builder_engine'
+
+module Parser
+
+  class XMLOutputFormat < OutputFormat
+
+    public
+
+      def initialize(pPath = "outputKuniri/")
+        @outputEngine = XMLBuilderEngine.new
+        set_path(pPath)
+      end
+
+      # @see OutputFormat
+      def class_generate(pClass)
+        # We use it because of the block below.
+        wrapper = self
+        pClass.each do |singleClass|
+          @outputEngine.classData :name => singleClass.name,
+                                  :visibility => singleClass.visibility do
+            wrapper.comment_generate(singleClass)
+
+            unless singleClass.aggregations.empty?
+              wrapper.aggregation_generate(singleClass.aggregations)
+            end
+            singleClass.inheritances.each do |singleInheritance|
+              wrapper.inheritance_generate(singleInheritance)
+            end
+            unless singleClass.attributes.empty?
+              wrapper.attribute_generate(singleClass.attributes)
+            end
+            singleClass.constructors.each do |singleConstructor|
+              wrapper.function_behaviour_generate("constructorData",
+                                                  singleConstructor)
+            end
+            singleClass.methods.each do |singleMethod|
+              wrapper.function_behaviour_generate("methodData" , singleMethod)
+            end
+          end
+        end
+      end
+
+      # @see OutputFormat
+      def function_behaviour_generate(pElementName, pFunction)
+        wrapper = self
+        @outputEngine.send(pElementName, {:name => pFunction.name,
+                                      :visibility => pFunction.visibility}) do
+          wrapper.comment_generate(pFunction)
+
+          pFunction.parameters.each do |parameter|
+            wrapper.parameters_generate(parameter)
+          end
+          unless pFunction.managerCondAndLoop.basicStructure.empty?
+            wrapper.basic_structure_generate(
+                                  pFunction.managerCondAndLoop.basicStructure)
+          end
+        end
+      end
+
+      # @see OutputFormat
+      def parameters_generate(pParameters)
+        if pParameters.is_a?Hash
+          pParameters.each do |nameParam, value|
+            @outputEngine.parameterData :name => "#{nameParam}=#{value}"
+          end
+        elsif pParameters.is_a?String
+          @outputEngine.parameterData :name => pParameters
+        end
+      end
+
+      # @see OutputFormat
+      def global_variable_generate(pGlobalVariable)
+        pGlobalVariable.each do |globalVar|
+          @outputEngine.globalVariableData :name => globalVar.name
+        end
+      end
+
+      # @see OutputFormat
+      def attribute_generate(pAttribute)
+        pAttribute.each do |singleAttribute|
+          @outputEngine.attributeData :name => singleAttribute.name,
+                                      :visibility => singleAttribute.visibility
+        end
+      end
+
+      # @see OutputFormat
+      def inheritance_generate(pInheritances)
+        pInheritances.each do |singleInheritance|
+          @outputEngine.inheritanceData :name => singleInheritance
+        end
+      end
+
+      # @see OutputFormat
+      def extern_requirement_generate(pRequirement)
+        pRequirement.each do |externRequirement|
+          @outputEngine.externRequirementData :name =>
+              externRequirement.library
+        end
+      end
+
+      # @see OutputFormat
+      def module_generate(pModule)
+        pModule.each do |singleModule|
+          @outputEngine.moduleData :name => singleModule.name
+        end
+      end
+
+      # @see OutputFormat
+      def basic_structure_generate(pBasicStructure)
+        simple_element(pBasicStructure)
+      end
+
+      def simple_element(pElement)
+        pElement.each do |element|
+          if element.type == Languages::ELSE_LABEL
+            @outputEngine.send(element.type.downcase,
+                              {:level => element.level})
+          else
+            @outputEngine.send(element.type.downcase,
+                              {:expression => element.expression,
+                               :level => element.level})
+          end
+        end
+      end
+
+      def comment_generate(pElement)
+        if pElement.comments != ""
+          @outputEngine.commentData :text => pElement.comments.gsub('"', "'")
+        end
+      end
+
+      def aggregation_generate(pAggregation)
+        pAggregation.each do |aggregation|
+          @outputEngine.aggregationData :name => aggregation.name
+        end
+      end
+
+  # class
+  end
+
+# module
+end

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

@@ -0,0 +1,45 @@
+require_relative 'oo_structured_state'
+
+module StateMachine
+
+  module OOStructuredFSM
+
+    # Class responsible for handling aggregation state.
+    class AggregationState < OOStructuredState
+
+      @language
+
+      def initialize(pLanguage)
+        @language = pLanguage
+      end
+
+      # @see OOStructuredState
+      def handle_line(pLine)
+      end
+
+      # @see OOStructuredState
+      def class_capture
+        @language.rewind_state
+      end
+
+      # @see OOStructuredState
+      def execute(pElementFile, pLine)
+        aggregationElement = @language.aggregationHandler.get_aggregation(pLine)
+
+        if aggregationElement
+            pElementFile.classes.last.aggregations.push aggregationElement
+            @language.metadata.allAggregations.push aggregationElement
+        end
+
+        class_capture
+        return pElementFile
+      end
+
+    # End class
+    end
+
+  # End OOStructuredFSM
+  end
+
+# End StateMachine
+end