kuniri 0.0.1

data/lib/kuniri/core/setting.rb

@@ -0,0 +1,143 @@
+require_relative 'configuration/language_available'
+require_relative 'configuration/monitor_available'
+require_relative 'configuration/log_available'
+
+require_relative '../util/html_logger'
+require_relative '../util/txt_logger'
+require_relative '../error/configuration_file_error'
+
+module Kuniri
+
+  # Class Setting that read and handling .kuniri file.
+  class Setting
+
+    public
+
+      private_class_method :new
+      attr_reader :configurationInfo
+      attr_reader :log
+
+      def initialize
+        initializate_settings
+      end
+
+      def Setting.create
+        @@settings = new unless @@settings
+        return @@settings
+      end
+
+      def initializate_settings(pFilePath = ".kuniri")
+        begin
+          @configurationInfo = read_configuration_file(pFilePath)
+          initialize_object
+        rescue Error::ConfigurationFileError
+          puts "You have a syntax problem on your configuration file."
+          abort
+        end
+
+      end
+ 
+      # Read the configuration file and return a list with the configurations.
+      # In this method it is checked the configuration file syntax.
+      # @param pPath [String] Path to ".kuniri" file, it means, the 
+      #         configurations.
+      # @return [Hash] Return a Hash with the configurations read in ".kuniri",
+      #     otherwise, raise an exception.
+      # @raise [type] Raise an syntax error if ".kuniri" has any syntax mistake
+      # @raise [type] Raised in the case of the path is wrong.
+      def read_configuration_file(pPath = ".kuniri")
+        configuration = {}
+
+        unless File.exists?(pPath)
+          # @log.write_log("Info: Not provide configuration file. Get default")
+          configuration = default_configuration
+        else
+          configuration = parser_configuration_file(pPath)
+        end
+
+        # @log.write_log("First reading configuration file: #{configuration}")
+
+        validate_field(configuration, "language") do |language|
+          Configuration::Language_Available::LANGUAGES.include?(language)
+        end
+
+        validate_field(configuration, "source") do |sourcePath|
+          File.exists?(sourcePath)
+        end
+
+        validate_field(configuration, "output") do |outputPath|
+          File.exists?(outputPath)
+        end
+
+        validate_field(configuration, "extract") do |extract|
+          Configuration::Monitor_Available::MONITORS.include?(extract.downcase)
+        end
+
+        validate_field(configuration, "log") do |log|
+          Configuration::Log_Available::LOG.include?(log.downcase)
+        end
+
+        # @log.write_log("Debug: Configuration: #{configuration}")
+
+        return configuration
+      end
+
+    private
+
+      @@settings = nil
+
+      def default_configuration
+        configuration = {"language" => "ruby",
+                          "source" => "./",
+                          "output" => "./",
+                          "extract" => "uml",
+                          "log" => "html"}
+        return configuration
+      end
+
+      def parser_configuration_file(pPath)
+        configuration = default_configuration
+
+        # @log.write_log("Debug: Reading cofiguration file in: #{pPath}")
+        File.open(pPath, mode="r").each_line do |line|
+          parts = line.split(':').size
+          unless (parts == 2)
+            # @log.write_log("Syntax error on configuration file.")
+            raise Error::ConfigurationFileError
+          end
+          key = handling_basic_syntax(line, 0)
+          value = handling_basic_syntax(line, 1)
+          configuration[key] = value
+        end
+        return configuration
+      end
+
+      def validate_field(pConfiguration_hash, pKey)
+        if pConfiguration_hash.has_key?(pKey)
+          value = pConfiguration_hash[pKey]
+          value.split(',').each do |element|
+            raise Error::ConfigurationFileError unless yield(element)
+          end
+        end
+      end
+
+      def handling_basic_syntax(pLine, pIndex)
+        text = pLine.split(':')[pIndex].downcase
+        text.gsub!(/\s/, '')
+        return text
+      end
+
+      def initialize_object
+        logType = @configurationInfo["log"]
+        if logType == "html"
+          @log = Util::HtmlLogger.new
+        elsif logType == "txt"
+          @log = Util::TxtLogger.new
+        end
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/error/configuration_file_error.rb

@@ -0,0 +1,12 @@
+# Error module, responsible for manage the errors.
+module Error
+
+  # Configuration_file_error is a class responsable for handling the many 
+  # different kind of error that can be raised in case of syntax error.
+  class ConfigurationFileError < RuntimeError
+
+  # Class
+  end
+
+# Error
+end

data/lib/kuniri/error/language_error.rb

@@ -0,0 +1,12 @@
+# Error module, responsible for manage the errors.
+module Error
+
+  # Configuration_file_error is a class responsable for handling the many 
+  # different kind of error that can be raised in case of syntax error.
+  class LanguageError < RuntimeError
+
+  # Class
+  end
+
+# Error
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/attribute.rb

@@ -0,0 +1,73 @@
+module Languages
+
+  # @abstract Abstract class for handling attribute.
+  class Attribute
+
+    public
+
+      # Verify if a line has an attribute. If it has attribute, firstly, the
+      # function capture all lines and removes specific language declaration
+      # (for instance, in ruby it is:  "@" or ":" and whitespace), finally
+      # it splits the string by an special character and return an object of
+      # AttributeData.
+      # @param pLine An line to be analysed for find attribute.
+      # @return Return on filled object of AttributeData if it find an
+      #         attribute, otherwise it returns nil.
+      def get_attribute(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # Detect if line has attribute.
+      # @param pLine Line with potential attribute.
+      # @return Return a matched STRING or nil if not found.
+      def detect_attribute(pLine)
+        raise NotImplementedError
+      end
+
+      # Remove unnecessary information from line. For example, remove
+      # everything into parenthesis or line comment.
+      # @param pString String for remove unnecessary information.
+      # @return If match any unnecessary character defined by the programmer
+      #         returns the new string, otherwise return the same string.
+      def remove_unnecessary_information(pString)
+        raise NotImplementedError
+      end
+
+      # Take the string, and do some final changes on the data before save it.
+      # @param pLine Target string to be saved. 
+      # @return Returns a final string or array with final attributes.
+      def prepare_final_string(pLine)
+        raise NotImplementedError
+      end
+
+      # Some attributes can be declared in the same line separated only by
+      # comma. Here is the place to handling it!
+      # @param pString String with all attributes separated by comma.
+      # @return Return an array of attributes.
+      def handle_multiple_declaration_with_comma(pString)
+        raise NotImplementedError
+      end
+
+      # Some languages allows do declare and set initial value in the same line
+      # by using equal. This method is responsible for handling this kind of
+      # situation.
+      # @param pString String with multiple declaration of string.
+      # @return Return an array of attributes.
+      def handle_multiple_declaration_with_equal(pString)
+        raise NotImplementedError
+      end
+
+      # Handling the simple case of line declaration
+      # @param pString String with attribute
+      # @return Return an String with the attribute.
+      def handle_line_declaration(pString)
+        raise NotImplementedError
+      end
+
+  # Class
+  end
+
+# Language
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/class.rb

@@ -0,0 +1,51 @@
+module Languages
+
+  # @abstract Class is an container for handling class
+  class Class
+
+    public
+
+      # Inspect line, and verify if it has a class or not.
+      # @param pLine Line with the potential class.
+      # @return Return an object ClassData if it find a class in the line,
+      #         otherwise return nil.
+      def get_class(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # Verify if line can have a class.
+      # @param pLine Line to inspect.
+      # @return Returns an row string with class name, otherwise returns nil.
+      def detect_class(pLine)
+        raise NotImplementedError
+      end
+
+      # Check if class has an inheritance inside.
+      # @param pString Line with the potential inheritance inside.
+      # @return Returns a string with the inheritance class, or return nil.
+      def get_inheritance(pString)
+        raise NotImplementedError
+      end
+
+      # Take an partial result of string, and remove unnecessary informations.
+      # @param pString Line with string.
+      # @return Return a string without any unnecessary information.
+      def remove_unnecessary_information(pString)
+        raise NotImplementedError
+      end
+
+      # Prepare final string before save it. Here it is the place to prune the
+      # final details in the string.
+      # @param pString String to be improved before save it.
+      # @return Returns a string prepared to be saved.
+      def prepare_final_string(pString)
+        raise NotImplementedError
+      end
+
+  # Class
+  end
+
+# Languages
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/comment.rb

@@ -0,0 +1,57 @@
+module Languages
+
+  # @abstract Class responsible for handling comments. Attention, this class
+  # is the only exception to the pattern. Usually, we implements a method
+  # called detect_something. However, in the case of comment, it is easier
+  # to create another set of methods.
+  class Comment
+
+    public
+
+      # This method is responsible for handling comments.
+      # @param pLine String to be analysed.
+      # @return Returns nil if doesn't find any comment line, or returns a
+      #         string with comments. Finally, if it find the final of
+      #         multiple line comment it returns END_MULTIPLE_LINE_COMMENT.
+      def get_comment(pLine)
+        raise NotImplementedError
+      end
+
+      # This method is responsible for checking if is a single line comment.
+      # @param pLine String for verify if is a single line comment.
+      # @return Return true if is a single line comment, otherwise, return
+      #         false.
+      def is_single_line_comment?(pLine)
+        raise NotImplementedError
+      end
+
+      # This method verify if it a multiple line comment.
+      # @param pLine String for verify if is a multiple line comment.
+      # @return Return true if is a multiple line comment, otherwise, return
+      #         false.
+      def is_multiple_line_comment?(pLine)
+        raise NotImplementedError
+      end
+
+      # This method verify if it is the end of multiple line comment.
+      # @param pLine String to be inspected.
+      # @return Return true if is the end of multiple line comment, otherwise,
+      #         return true.
+      def is_multiple_line_comment_end?(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # Method responsible for doing the final adjustment in the comment.
+      # @param pString Comment string to be handled.
+      # @return Return a string.
+      def prepare_line_comment(pString)
+        raise NotImplementedError
+      end
+
+  # End class
+  end
+
+# module
+end 

data/lib/kuniri/language/abstract_container/structured_and_oo/conditional.rb

@@ -0,0 +1,42 @@
+module Languages
+
+  # @abstract Class responsible for handling conditional instructions.
+  class Conditional
+
+    public
+
+      # Get conditional  
+      # @param pLine String with possible conditional statement.
+      # @return Returns an ConditionalData, otherwise return nil.
+      def get_conditional(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # Try to detect possible conditional in the line.
+      # @param pLine String with possible conditional event.
+      # @return Return a partial string, otherwise return nil.
+      def detect_conditional(pLine)
+        raise NotImplementedError
+      end
+
+      # Handling string type
+      # @param pString String for find the conditional type.
+      # @return Return a string with the type.
+      def conditional_type(pString)
+        raise NotImplementedError
+      end
+
+      # Try to extract the expression.
+      # @param pString String with conditional expression.
+      # @return Return a partial string.
+      def get_expression(pString)
+        raise NotImplementedError
+      end
+
+  # class
+  end
+
+# Languages
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/constructor.rb

@@ -0,0 +1,52 @@
+module Languages
+
+  # @abstract Constructor.
+  class Constructor
+
+    public
+
+      # Inspect line for trying to find a constructor.
+      # @param pLine String with potential function.
+      # @return Returns ConstructorData, or nil if line doesn't have method.
+      def get_constructor(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      @type
+
+      # Detect constructor in line
+      # @param pLine Line string with the potential constructor inside.
+      # @return Return the constructor if it is find in the string, otherwise
+      #         return nil
+      def detect_constructor(pLine)
+        raise NotImplementedError
+      end
+
+      # Trim unnecessary information from the string.
+      # @param pLine String for handling.
+      # @return Return an string.
+      def remove_unnecessary_information(pLine)
+        raise NotImplementedError
+      end
+
+      # Handling default parameters.
+      # @param pLine String with parameters.
+      # @return Return an array with default parameters.
+      def handling_default_parameter(pLine)
+        raise NotImplementedError
+      end
+
+      # Handling parameters.
+      # @param pLine String to try to find the parameters.
+      # @return Return a list with all the parameter, otherwise return nil
+      def handling_parameter(pLine)
+        raise NotImplementedError
+      end
+
+  # Class
+  end
+
+# Languages
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/end_block.rb

@@ -0,0 +1,27 @@
+module Languages
+
+  # @abstract Class responsible for handling end block of each language.
+  class EndBlock
+
+    public
+
+      # Verify if line has an end of line token.
+      # @param pLine Line to inspect.
+      # @return Return true if find an end block, otherwise return false.
+      def has_end_of_block?(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # Keeps some operation for find line.
+      # @param pLine Line with potential end of block.
+      def detect_end(pLine)
+        raise NotImplementedError
+      end
+
+  # End block
+  end
+
+# End module
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/extern_requirement.rb

@@ -0,0 +1,36 @@
+module Languages
+
+  # ExternRequirement is responsible for handling external requirement.
+  # An external requirement is the "#include" in C, "require" in Ruby,
+  # "import" in Java, etc.
+  class ExternRequirement
+
+    public
+
+      # Get requirement name.
+      # @param pLine Line to be analysed.
+      # @return Return the ExternRequirementData object, or nil.
+      def get_requirement(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # @param pLine Line to detect requirement.
+      # @return Returns a string with row extern requirement, or nil if not
+      #         detects anything.
+      def detect_extern_requirement(pLine)
+        raise NotImplementedError
+      end
+
+      # @param pLine Line with row string to be pruned.
+      # @return Returns an string.
+      def remove_unnecessary_information(pLine)
+        raise NotImplementedError
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/function_behavior.rb

@@ -0,0 +1,55 @@
+module Languages
+
+  # @abstract This class is responsible for handling elements whose the
+  # behaviour is similar to a function. For example, method and global
+  # function has a very similar behaviour, because of this is a good idea
+  # to use this class as parent.
+  class FunctionBehavior
+
+    public
+
+      # Verify if line has a potential function.
+      # @param pLine String with potencial function.
+      # @return Returns FuntionData, or nil if line doesn't have method.
+      def get_function(pLine, type = 'globalFunction')
+        raise NotImplementedError
+      end
+
+    protected
+
+      @type
+
+      # Detect function in line.
+      # @param pLine Line string with the potential method inside.
+      # @return Return the method if it is find in the string, othewise return
+      #   nil.
+      def detect_function(pLine)
+        raise NotImplementedError
+      end
+
+      # Remove unnecessary information inside the string.
+      # @param pLine Line for handling the string.
+      # @return Return a string.
+      def remove_unnecessary_information(pLine)
+        raise NotImplementedError
+      end
+
+      # Handling default parameters.
+      # @param pLine Line to be check.
+      # @return Return a string.
+      def handling_default_parameter(pLine)
+        raise NotImplementedError
+      end
+
+      # Handling parameters.
+      # @param pLine String to try to find the parameters.
+      # @return Return a list with all the parameter, othewise return nil
+      def handling_parameter(pLine)
+        raise NotImplementedError
+      end
+
+  # Class
+  end
+
+# Languages
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/module_namespace.rb

@@ -0,0 +1,36 @@
+module Languages
+
+  # @abstract Class responsible for handling namespaces, module, package or
+  # anything similar.
+  class ModuleNamespace
+
+    public
+
+      # Get a string and try to find a pattern, that match or not with module.
+      # @param pLine Receives a line for try to find module inside it.
+      # @return Return an ModuleNamespaceData.
+      def get_module(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # Verify if line has a potential module.
+      # @param pLine String for try to find a pattern.
+      # @return Return an string pre-processed, or nil in case of not match
+      #         string.
+      def detect_module(pLine)
+        raise NotImplementedError
+      end
+
+      # @param pLine Receives a line for handling.
+      # @return Return an string.
+      def remove_unnecessary_information(pLine)
+        raise NotImplementedError
+      end
+
+  # class
+  end
+
+# Languages module
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/repetition.rb

@@ -0,0 +1,42 @@
+module Languages
+
+  # @abstract Repetition class handling repetition structures.
+  class Repetition
+
+    public
+
+      # Get conditional.
+      # @param pLine String with possible repetition statement.
+      # @return Return an ConditionalData, otherwise return nil.
+      def get_repetition(pLine)
+        raise NotImplementedError
+      end
+
+    protected
+
+      # Try to detect possible repetition in the line.
+      # @param pLine String with possible repetition event.
+      # @return Return a partial string, otherwise return nil.
+      def detect_repetition(pLine)
+        raise NotImplementedError
+      end
+
+      # Handling string type
+      # @param pString String for find the repetition type.
+      # @return Return a string with the type.
+      def repetition_type(pString)
+        raise NotImplementedError
+      end
+
+      # Try to extract the expression.
+      # @param pString String with conditional expression.
+      # @return Return a partial string.
+      def get_expression(pString)
+        raise NotImplementedError
+      end
+
+  # class
+  end
+
+# Languages
+end