kuniri 0.0.1

data/data/function_behavior_lang.rb

@@ -0,0 +1,113 @@
+require_relative '../abstract_container/structured_and_oo/function_behavior'
+require_relative '../../core/setting'
+require_relative '../container_data/structured_and_oo/function_data'
+
+module Languages
+
+  module {LANG}
+
+    # Handling {LANG} method
+    class FunctionBehavior{LANG} < Languages::FunctionBehavior
+
+      public
+
+        def initialize
+          @log = @settings = Kuniri::Setting.create.log
+        end
+
+        def get_function(pLine, type = 'globalFunction')
+          result = detect_function(pLine)
+          return nil unless result
+
+          @log.write_log("Info: get method")
+
+          function{LANG} = Languages::FunctionData.new(result)
+
+          parameters = handling_parameter(pLine)
+          if parameters
+            parameters.each do |parameter|
+              function{LANG}.add_parameters(parameter)
+            end
+          end
+ 
+          @log.write_log("Debug: Method: #{function{LANG}.name}, Parameter:
+                         #{function{LANG}.parameters}")
+
+          return function{LANG}
+        end
+
+      protected
+
+        def detect_function(pLine)
+          regexExpression = /^\s*def\b\s*(\w*)\b/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression)[0].join("")
+        end
+
+        def handling_default_parameter(pLine)
+          return pLine unless pLine =~ /=/
+
+          if pLine =~ /,/
+            partialParameters = pLine.split(",")
+          else
+            partialParameters = [pLine]
+          end
+
+          newList = []
+          partialParameters.each do |element|
+            if element =~ /=/
+              parameter = element.scan(/(\w*)=/).join("")
+              value = element.scan(/=(\w*)/).join("")
+              defaultParameter = Hash(parameter => value)
+              newList.push(defaultParameter)
+              next
+            end
+            newList.push(element)
+          end
+
+          return newList
+
+        end
+
+        def remove_unnecessary_information(pLine)
+          return pLine.gsub(/\s+|\(|\)/,"") if pLine =~ /\s+|\(|\)/
+          return pLine
+        end
+
+        def handling_parameter(pLine)
+          # Handling with parenthesis and without it.
+          if pLine =~ /\(.+\)/
+            partial = get_parameters(pLine, /\(.+\)/)
+          elsif pLine =~ /def\s+\w+[\s]+(.+)/
+            partial = get_parameters(pLine, /def\s+\w+[\s]+(.+)/)
+          else
+            return nil
+          end
+
+          return handling_default_parameter(partial) if partial =~ /=/
+          return split_string_by_comma(partial)
+        end
+
+      private
+
+        @log
+
+        def get_parameters(pLine, pRegex)
+          partialParameters = pLine.scan(pRegex).join("")
+          partialParameters = remove_unnecessary_information(partialParameters)
+          return partialParameters
+        end
+
+        def split_string_by_comma(pString)
+          return pString.split(",") if pString =~ /,/
+          return [pString]
+        end
+
+    # Class
+    end
+
+  # {LANG}
+  end
+
+# Language
+end

data/data/lang_syntax.rb

@@ -0,0 +1,111 @@
+require_relative '../language'
+require_relative '../container_data/structured_and_oo/class_data'
+require_relative '../container_data/structured_and_oo/file_element'
+require_relative 'token_{lang}'
+require_relative 'extern_requirement_{lang}'
+require_relative 'variable_global_{lang}'
+require_relative 'module_namespace_{lang}'
+require_relative 'end_block_{lang}'
+require_relative 'constructor_{lang}'
+require_relative 'class_{lang}'
+require_relative 'conditional_{lang}'
+require_relative 'repetition_{lang}'
+require_relative 'function_behavior_{lang}'
+require_relative 'attribute_{lang}'
+
+module Languages
+
+  # Handling the {LANG} syntax for extract information.
+  class {LANG}Syntax < Languages::Language
+
+    public
+
+      def initialize
+        super
+        @externRequirementHandler = Languages::{LANG}::ExternRequirement{LANG}.new
+        @variableHandler = Languages::{LANG}::VariableGlobal{LANG}.new
+        @functionHandler = Languages::{LANG}::FunctionBehavior{LANG}.new
+        @moduleHandler = Languages::{LANG}::ModuleNamespace{LANG}.new
+        @classHandler = Languages::{LANG}::Class{LANG}.new
+        @attributeHandler = Languages::{LANG}::Attribute{LANG}.new
+        @endBlockHandler = Languages::{LANG}::EndBlock{LANG}.new
+        @methodHandler = Languages::{LANG}::FunctionBehavior{LANG}.new
+        @constructorHandler = Languages::{LANG}::Constructor{LANG}.new
+        @conditionalHandler = Languages::{LANG}::Conditional{LANG}.new
+        @repetitionHandler = Languages::{LANG}::Repetition{LANG}.new
+        @visibility = "public"
+      end
+
+      def analyse_source(pPath)
+        @name = File.basename(pPath, ".*")
+        @path = File.dirname(pPath)
+        analyse_first_step(pPath)
+        #self.analyse_second_step
+      end
+
+      # Extract all the comments from the source.
+      # @param source [String] Source code to analys.
+      def comment_extract
+        all_comments = Array.new
+        #Find a simple {LANG} comment with '#'
+        @source.scan(/#(.*)/).each do |comments|
+          all_comments.push(comments[0])
+        end
+        #Find multiple line comment.
+        @source.scan(/^=begin(.*?)^=end/m).each do |comment|
+          all_comments.push(comment[0].lstrip)
+        end
+        return all_comments
+      end
+
+      # Extract all method from the source.
+      # @param source [String]
+      def method_extract
+        return @currentClass.get_methods
+      end
+
+      # Extract all the class declared in the source.
+      # @param source [String]
+      def class_extract
+        return @currentClass
+      end
+
+      # @param source [String]
+      def attribute_extract
+        return @currentClass.get_attributes
+      end
+
+      # @param source [String]
+      def global_variable_extract
+        raise NotImplementedError
+      end
+
+      def extern_requirement_extract
+        return @externRequirements
+      end
+
+      def get_classes
+      end
+
+    private
+
+      attr_accessor :visibility
+      @source
+
+      def analyse_first_step(pPath)
+        fileElement = Languages::FileElement.new(pPath)
+        @source = File.open(pPath, "rb")
+        @source.each do |line|
+          next if line.gsub(/\s+/,"").size == 0
+          # Special token for class
+          @state.handle_line(line)
+          fileElement = @state.execute(fileElement, line)
+        end
+        @fileElements.push(fileElement)
+      end
+
+  # {LANG}
+  end
+
+# Module
+end

data/data/module_namespace_lang.rb

@@ -0,0 +1,43 @@
+require_relative '../abstract_container/structured_and_oo/module_namespace'
+require_relative '../container_data/structured_and_oo/module_namespace_data'
+
+module Languages
+
+  module {LANG}
+
+    # Class for handling {LANG} module
+    class ModuleNamespace{LANG} < Languages::ModuleNamespace
+
+      public
+
+        def get_module(pLine)
+          result = detect_module(pLine)
+          return nil unless result
+
+          result = remove_unnecessary_information(result)
+          moduleCaptured = Languages::ModuleNamespaceData.new(result)
+
+          return moduleCaptured
+        end
+
+      protected
+
+        def detect_module(pLine)
+          regexExpression = /^\s*module\s+(.*)/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression).join("")
+        end
+
+        def remove_unnecessary_information(pLine)
+          return pLine.gsub(/\s/, "") if pLine =~ /\s/
+          return pLine
+        end
+
+    # class
+    end
+
+  # {LANG}
+  end
+
+# module
+end

data/data/repetition_lang.rb

@@ -0,0 +1,62 @@
+require_relative '../abstract_container/structured_and_oo/repetition.rb'
+require_relative '../container_data/structured_and_oo/repetition_data.rb'
+
+module Languages
+
+  module {LANG}
+
+    class Repetition{LANG} < Languages::Repetition
+
+      public
+
+        def get_repetition(pLine)
+          result = detect_repetition(pLine)
+          return nil unless result
+
+          repetitionCaptured = Languages::RepetitionData.new
+          repetitionCaptured.type = repetition_type(pLine)
+
+          repetitionCaptured.expression = get_expression(result)
+
+          return repetitionCaptured
+        end
+
+      protected
+
+        def detect_repetition(pLine)
+          regexExp = /^\s*while\s+(.*)do/
+          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+
+          regexExp = /^\s*for\s+(.*)/
+          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+
+          regexExp = /^\s*until\s+(.*)do/
+          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+
+          return nil
+        end
+
+        def repetition_type(pString)
+          regexExp = /^\s+while|^while/
+          return "WHILE" if regexExp =~ pString
+
+          regexExp = /^\s+for|^for/
+          return "FOR" if regexExp =~ pString
+
+          return nil
+        end
+
+        def get_expression(pString)
+          leftStrip = pString.lstrip
+          rightStrip = leftStrip.rstrip
+          return rightStrip
+        end
+
+    # class
+    end
+
+  # {LANG}
+  end
+
+# Module
+end

data/data/token_lang.rb

@@ -0,0 +1,55 @@
+module Languages
+
+  module {LANG}
+
+    # Token types used to identify keywords
+    CLASS_TOKEN      ||= 1 # Executes the block passed to the method.
+    ATTRIBUTE_TOKEN  ||= 2
+    DEF_TOKEN        ||= 3
+    VISIBILITY_TOKEN ||= 4
+    END_TOKEN        ||= 5 # Code, enclosed in { and }, to run when the program ends.
+    IF_TOKEN         ||= 6 # Executes code block if true. Closes with end.
+    WHILE_TOKEN      ||= 7 # Executes the block passed to the method.
+    DO_TOKEN         ||= 8 # Begins a block and executes code in that block(end)
+    BEGIN_TOKEN      ||= 9 # Code, enclosed in { and }, to run before the program runs.
+    ALIAS_TOKEN      ||= 10 # Creates an alias: method, operator, or global variable.
+    AND_TOKEN        ||= 11 # Logical operator same as && except and has lower precedence.
+    BEGIN_DOWN_TOKEN ||= 12 # Begins a code block or group of statements (end).
+    BREAK_TOKEN      ||= 13 # Terminates a while or until loop or a method.
+    CASE_TOKEN       ||= 14 # Compares an expression with a matching when clause (end).
+    REQUIRE_TOKEN    ||= 15 # Extern requirement
+    DEFINED_TOKEN    ||= 16 # Determines: variable, method, super method, or block.
+    ELSE_TOKEN       ||= 17 # Executes if previous conditional.
+    ELSIF_TOKEN      ||= 18 # Executes if previous conditional, in if or elsif.
+    ENSURE_TOKEN     ||= 19 # Always executes at block termination.
+    FALSE_TOKEN      ||= 20 # Logical or Boolean false, instance of FalseClass.
+    TRUE_TOKEN       ||= 21 # Instance of TrueClass.
+    FOR_TOKEN        ||= 22 # Begins a for loop; used with in.
+    MODULE_TOKEN     ||= 23 # Defines a module; closes with end.
+    NEXT_TOKEN       ||= 24 # Jumps before a loop's conditional.
+    NIL_TOKEN        ||= 25 # Object of NilClass.
+    NOT_TOKEN        ||= 26 # Logical operator, same as !.
+    OR_TOKEN         ||= 27 # Logical operator, same as ||.
+    REDO_TOKEN       ||= 28 # Jumps after a loop's conditional.
+    RESCUE_TOKEN     ||= 29 # Evaluates an expression after an exception is raised.
+    RETRY_TOKEN      ||= 30 # Repeats a method call outside of rescue.
+    RETURN_TOKEN     ||= 31 # Returns a value from a method or block.
+    SELF_TOKEN       ||= 32 # Current object (invoked by a method).
+    SUPER_TOKEN      ||= 33 # Calls method of the same name in the superclass.
+    THEN_TOKEN       ||= 34 # A continuation for if, unless, and when.
+    UNDEF_TOKEN      ||= 35 # Makes a method in current class undefined.
+    UNLESS_TOKEN     ||= 36 # Executes code block if conditional statement is false.
+    UNTIL_TOKEN      ||= 37 # Executes code block while conditional statement is false.
+    WHEN_TOKEN       ||= 38 # Starts a clause (one or more) under case.
+    YIELD_TOKEN      ||= 39 # Executes the block passed to the method.
+    INTEGER_TOKEN    ||= 40
+    ARRAY_TOKEN      ||= 41
+    HASH_TOKEN       ||= 42
+    OBJECT_TOKEN     ||= 43
+    CONSTRUCTOR_TOKEN ||= 44
+
+    # Module
+  end
+
+# Language
+end

data/data/variable_global_lang.rb

@@ -0,0 +1,118 @@
+require_relative '../abstract_container/structured_and_oo/variable_global'
+require_relative '../container_data/structured_and_oo/variable_global_data'
+
+module Languages
+
+  module {LANG}
+
+    # @class VariableGlobal{LANG} Handling extern requirements.
+    class VariableGlobal{LANG} < Languages::VariableGlobal
+
+      public
+
+        def get_variable(pLine)
+          result = detect_variable(pLine)
+          return nil unless result
+
+          listOfVariable = []
+
+          # Separated by comma, equal or the common case
+          if result.split(",").size > 1
+            listOfVariable = handle_multiple_declaration_with_comma(result)
+          elsif result.split("=").size > 1
+            listOfVariable = handle_multiple_declaration_with_equal(result)
+          else
+            listOfVariable = handle_line_declaration(result)
+          end
+
+          return listOfVariable
+        end
+
+      protected
+
+        def detect_variable(pLine)
+          # Check basic case of non variable. Ex.: value x
+          pLine.gsub!(/^\s*/, "")
+          pLine.gsub!(/\s*$/, "")
+          return nil if pLine =~ /end/
+          return nil if pLine =~ /^def\s+/
+          return pLine if pLine.split(",").size > 1
+          return pLine if pLine.split("=").size > 1
+
+          return nil if pLine.split(" ").size > 1
+          return pLine
+        end
+
+        def remove_unnecessary_information(pLine)
+          return pLine
+        end
+
+        # Override
+        def prepare_final_string(pString)
+          if pString =~ /\s+|:|@|=/
+            return pString.gsub!(/\s+|:|@|=/,"")
+          end
+          return pString
+        end
+
+        # Override
+        def handle_multiple_declaration_with_comma(pString)
+          listOfVariable = []
+          pString = pString.split(",")
+          pString.each do |variable|
+            return nil if variable.split("=").size > 2
+
+            variable = variable.scan(/.*=/).join("") if variable =~ /.*=/
+
+            return nil if variable =~ /\./
+
+            variable = prepare_final_string(variable)
+            globalVariable = Languages::VariableGlobalData.new(variable)
+            listOfVariable.push(globalVariable)
+          end
+
+          return listOfVariable
+        end
+
+        # Override
+        def handle_multiple_declaration_with_equal(pString)
+          listOfVariable = []
+          pString = pString.split("=")
+          pString.each do |variable|
+            return nil if variable =~ /\./
+
+            variable = prepare_final_string(variable)
+            globalVariable = Languages::VariableGlobalData.new(variable)
+            listOfVariable.push(globalVariable)
+          end
+          value = listOfVariable.pop
+
+          return listOfVariable
+        end
+
+        # Override
+        def handle_line_declaration(pString)
+          listOfVariable = []
+          if pString =~ /=/
+            pString = pString.scan(/.*=/).join("")
+            return nil if pString =~ /\./
+          end
+
+          return nil if pString =~ /\./
+
+          pString = prepare_final_string(pString)
+          globalVariable = Languages::VariableGlobalData.new(pString)
+          listOfVariable.push(globalVariable)
+
+          return listOfVariable
+        end
+
+
+    # Class
+    end
+
+  # {LANG}
+  end
+
+# Module
+end

data/kuniri.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kuniri/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kuniri"
+  spec.version       = Kuniri::VERSION
+  spec.authors       = ["Gustavo Jaruga", "Rodrigo Siqueira"]
+  spec.email         = ["darksshades@hotmail.com", "rodrigosiqueiramelo@gmail.com"]
+  spec.summary       = %q{Extract class information from code.}
+  spec.description   = 'Generic parser'
+  spec.homepage      = "http://kuniri.github.io/kuniri/"
+  spec.license       = "GPLv3"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ["kuniri"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency 'nokogiri', '~> 1.6.6'
+end

data/lib/kuniri/core/configuration/language_available.rb

@@ -0,0 +1,7 @@
+module Configuration
+  #Handling the languages available in the system.
+  class Language_Available
+    public
+      LANGUAGES = ["ruby", "python", "c++", "c"] #Put here new language.
+  end
+end

data/lib/kuniri/core/configuration/log_available.rb

@@ -0,0 +1,7 @@
+module Configuration
+  # Configuration for the monitor available.
+  class Log_Available
+    public
+      LOG = ["html", "txt"] #List with log types.
+  end
+end

data/lib/kuniri/core/configuration/monitor_available.rb

@@ -0,0 +1,13 @@
+# Configuration module keep all the constants for make the system works.
+# | __Configure__ | __Description__ |
+# |---|---|
+# | Monitor  | Types of monitoring available. |
+# | Language | Languages available. |
+# | Watchdog | Types of watchdog. |
+module Configuration
+  # Configuration for the monitor available.
+  class Monitor_Available
+    public
+      MONITORS = ["uml", "traceability"] #List with monitors types.
+  end
+end

data/lib/kuniri/core/kuniri.rb

@@ -0,0 +1,78 @@
+require_relative '../error/configuration_file_error'
+require_relative '../parser/parser'
+require_relative '../util/logger'
+require_relative 'configuration/language_available'
+require_relative 'configuration/monitor_available'
+require_relative 'configuration/log_available'
+require_relative 'setting'
+
+# Kuniri module connect all the elements and use it in the proper sequence.
+module Kuniri
+
+  # Kuniri class have the reference for all files and settings. Basically this
+  # class launch the application.
+  class Kuniri
+
+    public
+
+      # @param pPath Receives the path of configuration file. If any element
+      #         is given, it tries to find in the current folder.
+      def initialize(pPath = ".kuniri")
+        @configurationInfo = {}
+        @filesPathProject = []
+        @parserFiles = []
+        @parser = nil
+
+        @settings = Setting.create
+        @settings.initializate_settings(pPath)
+        @log = @settings.log
+        @configurationInfo = @settings.configurationInfo
+
+        @log.write_log("info: Kuniri object successfully created.")
+      end
+
+      # Start Kuniri tasks based on configuration file. After read 
+      # configuration file, find all files in source directory.
+      def run_analysis()
+        @log.write_log("info: Start to run analysis.")
+        @log.write_log("debug: ConfigurationInfo: #{@configurationInfo}")
+
+        @filesPathProject = get_project_file(@configurationInfo["source"])
+        unless @filesPathProject
+          puts "Problem on source path: #{@configurationInfo["source"]}"
+          @log.write_log("Prolblem when tried to access source folder.")
+          return -1
+        end
+
+        @log.write_log("debug: files: #{@filesPathProject.to_s}")
+        @parser = Parser::Parser.new(@filesPathProject)
+        @parser.start_parser()
+      end
+ 
+      def get_parser
+        @parser
+      end
+
+    private
+
+      @configurationInfo # !@attribute Hash with configuration description
+      @filesProject      # !@attribute Array with object reference of all files
+      @parser            # !@attribute Execute the parser based on settings.
+      @parserFiles       # !@attribute Final output from parser.
+      @log               # !@attribute Log reference.
+
+      # !@param pPath Relative path of the project.
+      # !@param pLanguage Language extension for make the parser.
+      def get_project_file(pPath="./", pLanguage="**.rb")
+        return nil unless File.exists?(pPath)
+
+        @log.write_log("Info: Reading all files.")
+
+        @filesProject = Dir[File.join(pPath, "**", pLanguage)]
+      end
+
+  # Class
+  end
+
+# Kuniri
+end