kuniri 0.0.1 → 0.2

data/lib/kuniri/language/ruby/conditional_ruby.rb

@@ -1,4 +1,5 @@
 require_relative '../abstract_container/structured_and_oo/conditional'
+require_relative '../abstract_container/structured_and_oo/global_tokens'
 require_relative '../container_data/structured_and_oo/conditional_data'
 
 module Languages
@@ -18,8 +19,9 @@ module Languages
 
           conditionalCaptured = Languages::ConditionalData.new
           conditionalCaptured.type = conditional_type(pLine)
-
-          conditionalCaptured.expression = get_expression(result)
+          unless conditionalCaptured.type == Languages::ELSE_LABEL
+            conditionalCaptured.expression = get_expression(result)
+          end
 
           return conditionalCaptured
         end
@@ -34,28 +36,40 @@ module Languages
           regexExp = /^\s*case\s+(.*)/
           return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
 
+          regexExp = /^\s*when\s+(.*)/
+          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+
           regexExp = /^\s*unless\s+(.*)/
           return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
 
           regexExp = /^\s*elsif\s+(.*)/
           return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
 
+          regexExp = /^\s*else\s*/
+          return pLine.scan(regexExp)[0].gsub(" ", "") if regexExp =~ pLine
+
           return nil
         end
 
         # Override
         def conditional_type(pString)
           regexExp = /^\s+if|^if/
-          return "IF" if regexExp =~ pString
+          return Languages::IF_LABEL if regexExp =~ pString
 
           regexExp = /^\s+case|^case/
-          return "CASE" if regexExp =~ pString
+          return Languages::CASE_LABEL if regexExp =~ pString
+
+          regexExp = /^\s+when|^when/
+          return Languages::WHEN_LABEL if regexExp =~ pString
 
           regexExp = /^\s+unless|^unless/
-          return "UNLESS" if regexExp =~ pString
+          return Languages::UNLESS_LABEL if regexExp =~ pString
 
           regexExp = /^\s+elsif|^elsif/
-          return "ELSIF" if regexExp =~ pString
+          return Languages::ELSIF_LABEL if regexExp =~ pString
+
+          regexExp = /^\s+else|^else/
+          return Languages::ELSE_LABEL if regexExp =~ pString
 
           return nil
         end

data/lib/kuniri/language/ruby/constructor_ruby.rb

@@ -1,4 +1,3 @@
-require_relative '../abstract_container/structured_and_oo/constructor'
 require_relative '../container_data/structured_and_oo/constructor_data'
 require_relative 'function_behavior_ruby'
 
@@ -16,14 +15,13 @@ module Languages
         def get_constructor(pLine, type = 'public')
           result = get_function(pLine)
           return nil unless result
+          return nil unless result.name =~ /initialize/
 
-          if result.name =~ /initialize/
-            result.type = "CONSTRUCTOR"
-          else
-            return nil
-          end
+          constructorData = ConstructorData.new(result.name)
+          constructorData << result
+
+          return constructorData
 
-          return result
         end
 
     # Class

data/lib/kuniri/language/ruby/end_block_ruby.rb

@@ -19,7 +19,7 @@ module Languages
 
         def detect_end(pLine)
           #TODO: EXTREMELY SIMPLE HANDLING, IT HAVE TO BE IMPROVED!
-          return true if pLine =~ /^\s+end|^end/
+          return true if pLine =~ /^\s+end|^end|\send;?$/
           return false
         end
 

data/lib/kuniri/language/ruby/function_behavior_ruby.rb

@@ -12,7 +12,6 @@ module Languages
       public
 
         def initialize
-          @log = @settings = Kuniri::Setting.create.log
         end
 
         # Get Ruby function.
@@ -20,8 +19,6 @@ module Languages
           result = detect_function(pLine)
           return nil unless result
 
-          @log.write_log("Info: get method")
-
           functionRuby = Languages::FunctionData.new(result)
 
           parameters = handling_parameter(pLine)
@@ -30,9 +27,6 @@ module Languages
               functionRuby.add_parameters(parameter)
             end
           end
- 
-          @log.write_log("Debug: Method: #{functionRuby.name}, Parameter:
-                         #{functionRuby.parameters}")
 
           return functionRuby
         end
@@ -61,7 +55,7 @@ module Languages
             if element =~ /=/
               parameter = element.scan(/(\w*)=/).join("")
               value = element.scan(/=(\w*)/).join("")
-              defaultParameter = Hash(parameter => value)
+              defaultParameter = {parameter => value}
               newList.push(defaultParameter)
               next
             end
@@ -95,8 +89,6 @@ module Languages
 
       private
 
-        @log
-
         # Override
         def get_parameters(pLine, pRegex)
           partialParameters = pLine.scan(pRegex).join("")

data/lib/kuniri/language/ruby/global_function_ruby.rb

@@ -0,0 +1,32 @@
+require_relative '../container_data/structured_and_oo/function_data'
+require_relative 'function_behavior_ruby'
+
+module Languages
+
+  module Ruby
+
+    # Handling ruby global function
+    class GlobalFunctionRuby < Languages::Ruby::FunctionBehaviorRuby
+
+      public
+
+        # Get Ruby global function.
+        # @see FunctionBehaviorRuby
+        def get_method(pLine, type = 'public')
+          result = get_function(pLine)
+          return nil unless result
+
+          functionData = FunctionData.new(result.name)
+          functionData << result
+
+          return functionData
+        end
+
+    # Class
+    end
+
+  # Ruby
+  end
+
+# Language
+end

data/lib/kuniri/language/ruby/method_ruby.rb

@@ -0,0 +1,33 @@
+require_relative '../container_data/structured_and_oo/method_data'
+require_relative 'function_behavior_ruby'
+
+module Languages
+
+  module Ruby
+
+    # Handling ruby method
+    class MethodRuby < Languages::Ruby::FunctionBehaviorRuby
+
+      public
+
+        # Get Ruby method.
+        # @see FunctionBehaviorRuby
+        def get_method(pLine, type = 'public')
+          result = get_function(pLine)
+          return nil unless result
+          return nil if result.name =~ /initialize/
+
+          methodData = MethodData.new(result.name)
+          methodData << result
+
+          return methodData
+        end
+
+    # Class
+    end
+
+  # Ruby
+  end
+
+# Language
+end

data/lib/kuniri/language/ruby/repetition_ruby.rb

@@ -1,3 +1,4 @@
+require_relative '../abstract_container/structured_and_oo/global_tokens'
 require_relative '../abstract_container/structured_and_oo/repetition'
 require_relative '../container_data/structured_and_oo/repetition_data'
 
@@ -15,12 +16,12 @@ module Languages
         def get_repetition(pLine)
           result = detect_repetition(pLine)
           return nil unless result
-
+          #result = remove_unnecessary_information(result)
           repetitionCaptured = Languages::RepetitionData.new
-          repetitionCaptured.type = repetition_type(pLine)
-
-          repetitionCaptured.expression = get_expression(result)
-
+          repetitionCaptured.type = repetition_type(result)
+          repetitionCaptured.expression = get_expression(
+                                                    repetitionCaptured.type,
+                                                    result)
           return repetitionCaptured
         end
 
@@ -28,14 +29,24 @@ module Languages
 
         # Override
         def detect_repetition(pLine)
-          regexExp = /^\s*while\s+(.*)do/
-          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+          regexExp = /^\s*while\s+(.*)/
+          return pLine[regexExp, 0] if regexExp =~ pLine
+
+          regexExp = /^\s*for\s+(\w+)\s+in\s+(.+)(\bdo\b)?/
+          return pLine[regexExp, 0] if regexExp =~ pLine
 
-          regexExp = /^\s*for\s+(.*)/
-          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+          regexExp = /^\s*until\s+(.*)(\bdo\b)?/
+          return pLine[regexExp, 0] if regexExp =~ pLine
 
-          regexExp = /^\s*until\s+(.*)do/
-          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+          regexExp = /^\s*end\s+while\s+(.+)/
+          return pLine[regexExp, 0] if regexExp =~ pLine
+
+          regexExp = /(lambda)\s+do(.*)\s*/
+          return pLine[regexExp, 0] if regexExp =~ pLine
+
+          # TODO: BUG in this case -> puts "test.each do |x|"
+          regexExp = /\.(\s*\w+)\s+do(.*)\s*/
+          return pLine[regexExp, 0] if regexExp =~ pLine
 
           return nil
         end
@@ -43,21 +54,56 @@ module Languages
         # Override
         def repetition_type(pString)
           regexExp = /^\s+while|^while/
-          return "WHILE" if regexExp =~ pString
+          return Languages::WHILE_LABEL if regexExp =~ pString
 
           regexExp = /^\s+for|^for/
-          return "FOR" if regexExp =~ pString
+          return Languages::FOR_LABEL if regexExp =~ pString
+
+          regexExp = /^\s+until|^until/
+          return Languages::UNTIL_LABEL if regexExp =~ pString
+
+          regexExp = /^\s*end\s+while\s+/
+          return Languages::DO_WHILE_LABEL if regexExp =~ pString
+
+          regexExp = /^lambda\s+/
+          return Languages::LAMBDA_LABEL if regexExp =~ pString
+
+          regexExp = /\.\w+/
+          return pString[/\w+/, 0].upcase if regexExp =~ pString
 
           return nil
         end
 
         # Override
-        def get_expression(pString)
+        def get_expression(pType, pString)
+          case pType
+            when Languages::FOR_LABEL
+              pString.slice!("for")
+              pString.slice!("do")
+            when Languages::WHILE_LABEL
+              pString.slice!("while")
+              pString.slice!("do")
+            when Languages::UNTIL_LABEL
+              pString.slice!("until")
+              pString.slice!("do")
+            when Languages::DO_WHILE_LABEL
+              pString.slice!("end")
+              pString.slice!("while")
+            else
+              pString.slice!(".")
+          end
           leftStrip = pString.lstrip
           rightStrip = leftStrip.rstrip
+
           return rightStrip
         end
 
+        # Override
+        def remove_unnecessary_information(pString)
+          return pString.gsub(/\./,"") if pString =~ /\./
+          return pString
+        end
+
     # class
     end
 

data/lib/kuniri/language/ruby/ruby_syntax.rb

@@ -1,6 +1,6 @@
 require_relative '../language'
 require_relative '../container_data/structured_and_oo/class_data'
-require_relative '../container_data/structured_and_oo/file_element'
+require_relative '../container_data/structured_and_oo/file_element_data'
 require_relative 'token_ruby'
 require_relative 'extern_requirement_ruby'
 require_relative 'variable_global_ruby'
@@ -13,6 +13,9 @@ require_relative 'repetition_ruby'
 require_relative 'function_behavior_ruby'
 require_relative 'attribute_ruby'
 require_relative 'comment_ruby'
+require_relative 'method_ruby'
+require_relative 'aggregation_ruby'
+require_relative '../metadata'
 
 module Languages
 
@@ -30,11 +33,13 @@ module Languages
         @classHandler = Languages::Ruby::ClassRuby.new
         @attributeHandler = Languages::Ruby::AttributeRuby.new
         @endBlockHandler = Languages::Ruby::EndBlockRuby.new
-        @methodHandler = Languages::Ruby::FunctionBehaviorRuby.new
+        @methodHandler = Languages::Ruby::MethodRuby.new
         @constructorHandler = Languages::Ruby::ConstructorRuby.new
         @conditionalHandler = Languages::Ruby::ConditionalRuby.new
         @repetitionHandler = Languages::Ruby::RepetitionRuby.new
         @commentHandler = Languages::Ruby::CommentRuby.new
+        @aggregationHandler = Languages::Ruby::AggregationRuby.new
+        @metadata = Languages::Metadata.create
         @visibility = "public"
       end
 
@@ -44,70 +49,92 @@ module Languages
         @name = File.basename(pPath, ".*")
         @path = File.dirname(pPath)
         analyse_first_step(pPath)
-        #self.analyse_second_step
+        analyse_second_step
       end
 
-      # TODO: remove it.
-      def comment_extract
-        all_comments = Array.new
-        #Find a simple Ruby 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
-
-      # TODO: remove it.
-      def method_extract
-        return @currentClass.get_methods
-      end
-
-      # TODO: remove it.
-      def class_extract
-        return @currentClass
-      end
+    private
 
-      # TODO: remove it.
-      def attribute_extract
-        return @currentClass.get_attributes
-      end
+      attr_accessor :visibility
+      @source
+      @flagMultipleLineComment = false
 
-      # TODO: remove it.
-      def global_variable_extract
-        raise NotImplementedError
-      end
+      # Puts every statement in a single line
+      # @param pLine Line of the file to be analysed.
+      def handle_semicolon(pLine)
+        commentLine = []
 
-      # TODO: remove it.
-      def extern_requirement_extract
-        return @externRequirements
-      end
+        if pLine =~ /^=begin(.*?)/
+          @flagMultipleLineComment = true
+        elsif pLine =~ /^=end/
+          @flagMultipleLineComment = false
+        end
 
-      # TODO: remove it.
-      def get_classes
+        unless @flagMultipleLineComment == true || pLine =~ /#(.*)/
+          return pLine.split(/;/)
+        end
+        commentLine << pLine
       end
 
-    private
-
-      attr_accessor :visibility
-      @source
-
       # First step for analyse code, it is responsible for get only basic
       # informations.
       # @param pPath Path of file to be analysed.
       def analyse_first_step(pPath)
-        fileElement = Languages::FileElement.new(pPath)
+        fileElement = Languages::FileElementData.new(pPath)
         @source = File.open(pPath, "rb")
         @source.each do |line|
           next if line.gsub(/\s+/,"").size == 0
-
-          @state.handle_line(line)
-          fileElement = @state.execute(fileElement, line)
+          processedLines = handle_semicolon(line)
+          if !processedLines.nil?
+            processedLines.each do |line|
+              @state.handle_line(line)
+              fileElement = @state.execute(fileElement, line)
+            end
+          end
         end
+
+        @source.close()
         @fileElements.push(fileElement)
+
+      end
+
+      def analyse_second_step
+        sort_all_classes
+        sort_all_aggregations
+
+        allActualAggregations = []
+
+        @metadata.allAggregations.each do |element|
+          if binary_search(@metadata.allClasses, element)
+            allActualAggregations << element
+          end
+        end
+
+        # TODO: Think how to improve.
+        @fileElements.each do |fileElement|
+          fileElement.classes.each do |classes|
+            classes.aggregations.delete_if do |aggregation|
+              unless allActualAggregations.include? aggregation
+                true
+              end
+            end
+          end
+        end
+      end
+
+      # TODO: Move it to utils
+      def binary_search(pVector, pElement)
+        pVector.bsearch {|obj| pElement.name <=> obj.name}
+      end
+
+      # TODO: Move it to utils
+      def sort_all_classes
+        @metadata.allClasses.sort! {|c1, c2| c1.name <=> c2.name}
+      end
+
+      # TODO: Move it to utils
+      def sort_all_aggregations
+        @metadata.allAggregations.sort! {|a1, a2| a1.name <=> a2.name}
+        @metadata.allAggregations.uniq! {|a| a.name}
       end
 
   # Class