kuniri 0.0.1 → 0.2

data/data/variable_global_lang.rb

@@ -5,113 +5,54 @@ module Languages
 
   module {LANG}
 
-    # @class VariableGlobal{LANG} Handling extern requirements.
+    # VariableGlobal{LANG} Handling extern requirements.
     class VariableGlobal{LANG} < Languages::VariableGlobal
 
       public
 
+        # Get {LANG} variable.
+        # @see Languages::VariableGlobal
         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
+          # YOUR CODE HERE
         end
 
       protected
 
+        # Override
         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
+          # YOUR CODE HERE
         end
 
+        # Override
         def remove_unnecessary_information(pLine)
-          return pLine
+          # YOUR CODE HERE
         end
 
         # Override
         def prepare_final_string(pString)
-          if pString =~ /\s+|:|@|=/
-            return pString.gsub!(/\s+|:|@|=/,"")
-          end
-          return pString
+          # YOUR CODE HERE
         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
+          # YOUR CODE HERE
         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
+          # YOUR CODE HERE
         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
+          # YOUR CODE HERE
         end
 
 
     # Class
     end
 
-  # {LANG}
+  # Module
   end
 
 # Module

data/kuniri.gemspec

@@ -3,15 +3,15 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'kuniri/version'
 
-Gem::Specification.new do |spec|
+Gem::Specification.new 'kuniri', '0.2' do |spec|
   spec.name          = "kuniri"
   spec.version       = Kuniri::VERSION
   spec.authors       = ["Gustavo Jaruga", "Rodrigo Siqueira"]
-  spec.email         = ["darksshades@hotmail.com", "rodrigosiqueiramelo@gmail.com"]
+  spec.email         = ["darksshades@hotmail.com", "siqueira@kuniri.org"]
   spec.summary       = %q{Extract class information from code.}
   spec.description   = 'Generic parser'
   spec.homepage      = "http://kuniri.github.io/kuniri/"
-  spec.license       = "GPLv3"
+  spec.license       = "LGPLv3"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = ["kuniri"]
@@ -19,6 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rspec"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_runtime_dependency 'nokogiri', '~> 1.6.6'
 end

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

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

data/lib/kuniri/core/kuniri.rb

@@ -1,9 +1,6 @@
 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.
@@ -15,60 +12,71 @@ module Kuniri
 
     public
 
+      attr_reader :configurationInfo # !@attribute Hash with configuration description
+
       # @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")
+      def initialize
         @configurationInfo = {}
         @filesPathProject = []
         @parserFiles = []
         @parser = nil
 
+      end
+
+      def read_configuration_file(pPath = ".kuniri.yml")
         @settings = Setting.create
         @settings.initializate_settings(pPath)
-        @log = @settings.log
+        @settings.read_configuration_file(pPath)
         @configurationInfo = @settings.configurationInfo
+      end
 
-        @log.write_log("info: Kuniri object successfully created.")
+      def set_configuration(pSource, pLanguage, pOutput, pLevel)
+        @settings = Setting.create
+        @settings.initializate_settings
+        @settings.set_configuration(pSource, pLanguage, pOutput, pLanguage)
+        # XXX: Extremely "gambira" PLEASE, REMOVE METHOD BELOW!
+        @configurationInfo = @settings.configurationInfo
       end
 
-      # Start Kuniri tasks based on configuration file. After read 
+      # 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"])
+        @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.")
+          puts "Problem on source path: #{@configurationInfo[:source]}"
           return -1
         end
-
-        @log.write_log("debug: files: #{@filesPathProject.to_s}")
-        @parser = Parser::Parser.new(@filesPathProject)
-        @parser.start_parser()
+        @parser = Parser::Parser.new(@filesPathProject,
+                                      @configurationInfo[:language])
+  	    @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.")
+        # Verify if path is a valid directory or file
+        return nil unless File.file?(pPath) or File.directory?(pPath)
+
+        # Handle single file
+        if (File.file?(pPath))
+          @filesProject = [pPath]
+        # Handle multiple files
+        else
+          @filesProject = Dir[File.join(pPath, "**", pLanguage)]
+        end
 
-        @filesProject = Dir[File.join(pPath, "**", pLanguage)]
+        return @filesProject
       end
 
   # Class

data/lib/kuniri/core/setting.rb

@@ -1,9 +1,5 @@
+require 'yaml'
 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
@@ -15,7 +11,6 @@ module Kuniri
 
       private_class_method :new
       attr_reader :configurationInfo
-      attr_reader :log
 
       def initialize
         initializate_settings
@@ -26,113 +21,84 @@ module Kuniri
         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
-
+      # TODO: Remove parameter and initialize_object. Useless.
+      def initializate_settings(pFilePath = ".kuniri.yml")
+          #@configurationInfo = read_configuration_file(pFilePath)
+          @configurationInfo = {}
       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 
+      # @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 = {}
+      def read_configuration_file(pPath = ".kuniri.yml")
 
         unless File.exists?(pPath)
-          # @log.write_log("Info: Not provide configuration file. Get default")
-          configuration = default_configuration
+          set_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)
+          @configurationInfo = YAML.load(File.read(pPath))
+          verify_syntax
         end
 
-        validate_field(configuration, "log") do |log|
-          Configuration::Log_Available::LOG.include?(log.downcase)
-        end
-
-        # @log.write_log("Debug: Configuration: #{configuration}")
+        return @configurationInfo
+      end
 
-        return configuration
+      def set_configuration(pSource, pLanguage, pOutput, pLevel)
+        @configurationInfo[:source] = pSource
+        @configurationInfo[:language] = pLanguage
+        @configurationInfo[:output] = pOutput
+        @configurationInfo[:level] = pLevel
+        return @configurationInfo
       end
 
     private
 
       @@settings = nil
 
-      def default_configuration
-        configuration = {"language" => "ruby",
-                          "source" => "./",
-                          "output" => "./",
-                          "extract" => "uml",
-                          "log" => "html"}
-        return configuration
+      def set_default_configuration
+        @configurationInfo = {:language => "ruby",
+                               :source => "./",
+                               :output => "./"}
       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
+      def verify_syntax
+        unless @configurationInfo.is_a? Hash
+          raise Error::ConfigurationFileError
         end
-        return configuration
+
+        check_source
+        check_output
+        check_language
       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)
+      def check_source
+        unless @configurationInfo.has_key?:source
+          raise Error::ConfigurationFileError
+        else
+          source = @configurationInfo[:source]
+          result = (File.directory?source) || (File.exists?source)
+          unless result
+            raise Error::ConfigurationFileError
           end
         end
       end
 
-      def handling_basic_syntax(pLine, pIndex)
-        text = pLine.split(':')[pIndex].downcase
-        text.gsub!(/\s/, '')
-        return text
+      def check_output
+        unless @configurationInfo.has_key?:output
+          raise Error::ConfigurationFileError
+        end
       end
 
-      def initialize_object
-        logType = @configurationInfo["log"]
-        if logType == "html"
-          @log = Util::HtmlLogger.new
-        elsif logType == "txt"
-          @log = Util::TxtLogger.new
+      def check_language
+        unless @configurationInfo.has_key?:language
+          raise Error::ConfigurationFileError
+        else
+          result = Configuration::LanguageAvailable::LANGUAGES.include?(
+                                                @configurationInfo[:language])
+          unless result
+            raise Error::ConfigurationFileError
+          end
         end
       end
 

data/lib/kuniri/error/parser_error.rb

@@ -0,0 +1,9 @@
+module Error
+
+  class ParserError < RuntimeError
+
+  # Class
+  end
+
+# Error
+end