kuniri 0.0.1

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

@@ -0,0 +1,33 @@
+require_relative '../abstract_container/structured_and_oo/end_block'
+
+module Languages
+
+  module Ruby
+
+    # Class responsible for handling Ruby end of block.
+    class EndBlockRuby < Languages::EndBlock
+
+      public
+
+        # Verify Ruby end of block.
+        # @see EndBlock
+        def has_end_of_block?(pLine)
+          return detect_end(pLine)
+        end
+
+      protected
+
+        def detect_end(pLine)
+          #TODO: EXTREMELY SIMPLE HANDLING, IT HAVE TO BE IMPROVED!
+          return true if pLine =~ /^\s+end|^end/
+          return false
+        end
+
+    # Class
+    end
+
+  # Module
+  end
+
+# Module
+end

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

@@ -0,0 +1,49 @@
+require_relative '../abstract_container/structured_and_oo/extern_requirement'
+require_relative '../container_data/structured_and_oo/extern_requirement_data'
+
+module Languages
+
+  module Ruby
+
+    # ExternRequirement Handling extern requirements.
+    class ExternRequirementRuby < Languages::ExternRequirement
+
+      public
+
+        # Get Ruby requirement.
+        # @see ExternRequirement
+        def get_requirement(pLine)
+          detectExpression = detect_extern_requirement(pLine)
+          return nil unless detectExpression
+
+          detectExpression = remove_unnecessary_information(detectExpression)
+          # @requirement = detectExpression
+          name = File.basename(detectExpression, ".*")
+          externReference = ExternRequirementData.new(name)
+          return externReference
+        end
+
+      protected
+
+        # Override
+        def detect_extern_requirement(pLine)
+          regexExpression = /^\s*require(?:_relative)?\s+('|")(.*)\1/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression).join("")
+        end
+
+        # Override
+        def remove_unnecessary_information(pLine)
+          regexClean = /\s+|"|'/
+          return pLine.gsub!(regexClean, "") if pLine =~ regexClean
+          return pLine
+        end
+
+    # Class
+    end
+
+  # Module
+  end
+
+# Module
+end 

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

@@ -0,0 +1,120 @@
+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 Ruby
+
+    # Handling Ruby method
+    class FunctionBehaviorRuby < Languages::FunctionBehavior
+
+      public
+
+        def initialize
+          @log = @settings = Kuniri::Setting.create.log
+        end
+
+        # Get Ruby function.
+        def get_function(pLine, type = 'globalFunction')
+          result = detect_function(pLine)
+          return nil unless result
+
+          @log.write_log("Info: get method")
+
+          functionRuby = Languages::FunctionData.new(result)
+
+          parameters = handling_parameter(pLine)
+          if parameters
+            parameters.each do |parameter|
+              functionRuby.add_parameters(parameter)
+            end
+          end
+ 
+          @log.write_log("Debug: Method: #{functionRuby.name}, Parameter:
+                         #{functionRuby.parameters}")
+
+          return functionRuby
+        end
+
+      protected
+
+        # Override
+        def detect_function(pLine)
+          regexExpression = /^\s*def\b\s*(\w*)\b/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression)[0].join("")
+        end
+
+        # Override
+        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
+
+        # Override
+        def remove_unnecessary_information(pLine)
+          return pLine.gsub(/\s+|\(|\)/,"") if pLine =~ /\s+|\(|\)/
+          return pLine
+        end
+
+        # Override
+        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
+
+        # Override
+        def get_parameters(pLine, pRegex)
+          partialParameters = pLine.scan(pRegex).join("")
+          partialParameters = remove_unnecessary_information(partialParameters)
+          return partialParameters
+        end
+
+        # Override
+        def split_string_by_comma(pString)
+          return pString.split(",") if pString =~ /,/
+          return [pString]
+        end
+
+    # Class
+    end
+
+  # Ruby
+  end
+
+# Language
+end

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

@@ -0,0 +1,47 @@
+require_relative '../abstract_container/structured_and_oo/module_namespace'
+require_relative '../container_data/structured_and_oo/module_namespace_data'
+
+module Languages
+
+  module Ruby
+
+    # Class for handling ruby module
+    class ModuleNamespaceRuby < Languages::ModuleNamespace
+    
+      public
+
+        # Get Ruby module.
+        # @see Languages::ModuleNamespace
+        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
+
+        # Override
+        def detect_module(pLine)
+          regexExpression = /^\s*module\s+(.*)/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression).join("")
+        end
+
+        # Override
+        def remove_unnecessary_information(pLine)
+          return pLine.gsub(/\s/, "") if pLine =~ /\s/
+          return pLine
+        end
+
+    # class
+    end
+
+  # module
+  end
+
+# module
+end

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

@@ -0,0 +1,68 @@
+require_relative '../abstract_container/structured_and_oo/repetition'
+require_relative '../container_data/structured_and_oo/repetition_data'
+
+module Languages
+
+  module Ruby
+
+    # Class responsible for handling Ruby repetition data structures.
+    class RepetitionRuby < Languages::Repetition
+
+      public
+
+        # Get Ruby repetition structure.
+        # @see Languages::Repetition
+        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
+
+        # Override
+        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
+
+        # Override
+        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
+
+        # Override
+        def get_expression(pString)
+          leftStrip = pString.lstrip
+          rightStrip = leftStrip.rstrip
+          return rightStrip
+        end
+
+    # class
+    end
+
+  # Module
+  end
+
+# Module
+end

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

@@ -0,0 +1,117 @@
+require_relative '../language'
+require_relative '../container_data/structured_and_oo/class_data'
+require_relative '../container_data/structured_and_oo/file_element'
+require_relative 'token_ruby'
+require_relative 'extern_requirement_ruby'
+require_relative 'variable_global_ruby'
+require_relative 'module_namespace_ruby'
+require_relative 'end_block_ruby'
+require_relative 'constructor_ruby'
+require_relative 'class_ruby'
+require_relative 'conditional_ruby'
+require_relative 'repetition_ruby'
+require_relative 'function_behavior_ruby'
+require_relative 'attribute_ruby'
+require_relative 'comment_ruby'
+
+module Languages
+
+  # Handling the ruby syntax for extract information.
+  class RubySyntax < Languages::Language
+
+    public
+
+      def initialize
+        super
+        @externRequirementHandler = Languages::Ruby::ExternRequirementRuby.new
+        @variableHandler = Languages::Ruby::VariableGlobalRuby.new
+        @functionHandler = Languages::Ruby::FunctionBehaviorRuby.new
+        @moduleHandler = Languages::Ruby::ModuleNamespaceRuby.new
+        @classHandler = Languages::Ruby::ClassRuby.new
+        @attributeHandler = Languages::Ruby::AttributeRuby.new
+        @endBlockHandler = Languages::Ruby::EndBlockRuby.new
+        @methodHandler = Languages::Ruby::FunctionBehaviorRuby.new
+        @constructorHandler = Languages::Ruby::ConstructorRuby.new
+        @conditionalHandler = Languages::Ruby::ConditionalRuby.new
+        @repetitionHandler = Languages::Ruby::RepetitionRuby.new
+        @commentHandler = Languages::Ruby::CommentRuby.new
+        @visibility = "public"
+      end
+
+      # Analyse source code.
+      # @param pPath Path of file to be analysed.
+      def analyse_source(pPath)
+        @name = File.basename(pPath, ".*")
+        @path = File.dirname(pPath)
+        analyse_first_step(pPath)
+        #self.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
+
+      # TODO: remove it.
+      def attribute_extract
+        return @currentClass.get_attributes
+      end
+
+      # TODO: remove it.
+      def global_variable_extract
+        raise NotImplementedError
+      end
+
+      # TODO: remove it.
+      def extern_requirement_extract
+        return @externRequirements
+      end
+
+      # TODO: remove it.
+      def get_classes
+      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)
+        @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)
+        end
+        @fileElements.push(fileElement)
+      end
+
+  # Class
+  end
+
+# Module
+end

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

@@ -0,0 +1,59 @@
+#reference: 
+# http://www.java2s.com/Code/Ruby/Language-Basics/Rubysreservedwords.htm
+
+module Languages
+
+  # Module responsible for handling ruby syntax.
+  module Ruby
+
+    # 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/lib/kuniri/language/ruby/variable_behaviour_ruby.rb

@@ -0,0 +1,83 @@
+require_relative '../abstract_container/structured_and_oo/variable_behaviour'
+
+module Languages
+
+  module Ruby
+
+    # Ruby Handling Ruby attributes
+    class VariableBehaviourRuby < Languages::VariableBehaviour
+
+      protected
+
+        # Override
+        def remove_unnecessary_information(pString)
+          return pString.gsub!(/\(.*\)/,"") if pString =~ /\(.*\)/
+          return pString
+        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)
+          listOfAttributes = []
+          pString = pString.split(",")
+          pString.each do |variable|
+            return nil if variable.scan(/=/).count > 1
+
+            variable = variable.scan(/.*=/).join("") if variable =~ /.*=/
+
+            return nil if variable =~ /\./
+
+            variable = prepare_final_string(variable)
+            finalVariableElement = yield(variable)
+            listOfAttributes.push(finalVariableElement)
+          end
+
+          return listOfAttributes
+        end
+
+        # Override
+        def handle_multiple_declaration_with_equal(pString)
+          listOfAttributes = []
+          pString = pString.split("=")
+          pString.each do |variable|
+            return nil if variable =~ /\./
+
+            variable = prepare_final_string(variable)
+            attribute = yield(variable)
+            listOfAttributes.push(attribute)
+          end
+
+          return listOfAttributes
+        end
+
+        # Override
+        def handle_line_declaration(pString)
+          listOfAttributes = []
+          if pString =~ /=/
+            pString = pString.scan(/.*=/).join("")
+            return nil if pString =~ /\./
+          end
+
+          return nil if pString =~ /\./
+
+          pString = prepare_final_string(pString)
+          attribute = yield(pString)
+          listOfAttributes.push(attribute)
+
+          return listOfAttributes
+        end
+
+    #Class
+    end
+
+  # Ruby
+  end
+#Language
+end

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

@@ -0,0 +1,123 @@
+require_relative '../abstract_container/structured_and_oo/variable_global'
+require_relative '../container_data/structured_and_oo/variable_global_data'
+
+module Languages
+
+  module Ruby
+
+    # VariableGlobalRuby Handling extern requirements.
+    class VariableGlobalRuby < Languages::VariableGlobal
+
+      public
+
+        # Get Ruby 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
+        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 nil if pLine =~ /=begin/
+          return pLine if pLine.split(",").size > 1
+          return pLine if pLine.split("=").size > 1
+
+          return nil if pLine.split(" ").size > 1
+          return pLine
+        end
+
+        # Override
+        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
+
+  # Module
+  end
+
+# Module
+end