kuniri 0.0.1

data/lib/kuniri/language/language.rb

@@ -0,0 +1,222 @@
+require_relative '../state_machine/OO_structured_fsm/attribute_state'
+require_relative '../state_machine/OO_structured_fsm/class_state'
+require_relative '../state_machine/OO_structured_fsm/constructor_state'
+require_relative '../state_machine/OO_structured_fsm/function_state'
+require_relative '../state_machine/OO_structured_fsm/idle_state'
+require_relative '../state_machine/OO_structured_fsm/include_state'
+require_relative '../state_machine/OO_structured_fsm/method_state'
+require_relative '../state_machine/OO_structured_fsm/module_state'
+require_relative '../state_machine/OO_structured_fsm/variable_state'
+require_relative '../state_machine/OO_structured_fsm/oo_structured_state'
+require_relative '../state_machine/OO_structured_fsm/conditional_state'
+require_relative '../state_machine/OO_structured_fsm/repetition_state'
+require_relative '../state_machine/OO_structured_fsm/comment_state'
+
+# Module that keeps the language syntax.
+module Languages
+
+  # @abstract Abstract class for handling different types of language.
+  class Language
+
+    public
+
+      attr_reader :name
+      attr_reader :path
+
+      attr_reader :attributeState
+      attr_reader :state
+      attr_reader :previousState
+      attr_reader :classState
+      attr_reader :constructorState
+      attr_reader :functionState
+      attr_reader :idleState
+      attr_reader :includeState
+      attr_reader :methodState
+      attr_reader :moduleState
+      attr_reader :variableState
+      attr_reader :conditionalState
+      attr_reader :repetitionState
+      attr_reader :commentState
+
+      attr_reader :externRequirementHandler
+      attr_reader :variableHandler
+      attr_reader :functionHandler
+      attr_reader :moduleHandler
+      attr_reader :classHandler
+      attr_reader :endBlockHandler
+      attr_reader :attributeHandler
+      attr_reader :methodHandler
+      attr_reader :constructorHandler
+      attr_reader :conditionalHandler
+      attr_reader :repetitionHandler
+      attr_reader :commentHandler
+
+      attr_accessor :fileElements
+
+      # Those values help state machine to understand which place to add
+      # conditional information and repetition data.
+      attr_accessor :flagFunctionBehaviour
+
+      attr_accessor :string_comment_to_transfer
+
+      # This method initialize all the needed states of state machine.
+      # @note: Never forget to call this method before start parser.
+      def initialize
+        @attributeState =
+          StateMachine::OOStructuredFSM::AttributeState.new(self)
+        @classState = StateMachine::OOStructuredFSM::ClassState.new(self)
+        @constructorState =
+          StateMachine::OOStructuredFSM::ConstructorState.new(self)
+        @functionState = StateMachine::OOStructuredFSM::FunctionState.new(self)
+        @idleState = StateMachine::OOStructuredFSM::IdleState.new(self)
+        @includeState = StateMachine::OOStructuredFSM::IncludeState.new(self)
+        @methodState = StateMachine::OOStructuredFSM::MethodState.new(self)
+        @moduleState = StateMachine::OOStructuredFSM::ModuleState.new(self)
+        @variableState = StateMachine::OOStructuredFSM::VariableState.new(self)
+        @conditionalState =
+          StateMachine::OOStructuredFSM::ConditionalState.new(self)
+        @repetitionState =
+          StateMachine::OOStructuredFSM::RepetitionState.new(self)
+        @commentState = StateMachine::OOStructuredFSM::CommentState.new(self)
+
+        @state = @idleState
+        @previousState = []
+        @previousState.push (@state)
+
+        @fileElements = []
+        @flagFunctionBehaviour = nil
+
+        @string_comment_to_transfer = ""
+      end
+
+      # Set the source code to by analysed.
+      # @param pSource [String] Set the source string.
+      def set_source(pSource)
+        @source = pSource
+      end
+
+      # Based on the source, extract the informations inside of it. For example
+      # in this is step the algorithm try to find classes, and methods. This
+      # method, work like a hook for give more flexibility to implements any
+      # needed steps.
+      def analyse_source
+        raise NotImplementedError
+      end
+
+      # Extract all the comments from the source.
+      def comment_extract
+        raise NotImplementedError
+      end
+
+      # Extract all the method/function from the source.
+      def method_extract
+        raise NotImplementedError
+      end
+
+      # Extract all the class declared in the source.
+      def class_extract
+        raise NotImplementedError
+      end
+
+      # Extract the attribute from source file.
+      def attribute_extract
+        raise NotImplementedError
+      end
+
+      # Extract global variables.
+      def global_variable_extract
+        raise NotImplementedError
+      end
+
+      # Take all the extern requirements
+      def extern_requirement_extract
+        raise NotImplementedError
+      end
+
+      # Rewind state
+      def rewind_state
+        @state = @previousState.pop
+      end
+
+      # TODO: REMOVE IT
+      def get_name
+        return @name
+      end
+
+      # TODO: REMOVE IT
+      def get_path
+        return @path
+      end
+
+      # Handling line
+      def handle_line(pLine)
+        @state.handle_line
+      end
+
+      # Handling class state, i.e, this state is enable when any class is match
+      def class_capture
+        @state.class_capture
+      end
+
+      # Handling method state, this state is enable only after class state.
+      def method_capture
+        @state.method_capture
+      end
+
+      # Handling constructor, only after class state.
+      def constructor_capture
+        @state.constructor_capture
+      end
+
+      # Handling attribute state.
+      def attribute_capture
+        @state.attribute_capture
+      end
+
+      # Handling module, it can be oriented object or structured.
+      def module_capture
+        @state.module_capture
+      end
+
+      # Handling function, it is related with structured state
+      # but not exclusively.
+      def function_capture
+        @state.function_capture
+      end
+
+      # Handling external include
+      def include_capture
+        @state.include_capture
+      end
+
+      # Handling variable
+      def variable_capture
+        @state.variable_capture
+      end
+
+      # Idle state, waiting for action! =D
+      def idle_capture
+        @state.idle_capture
+      end
+
+      # Conditional state.
+      def conditional_capture
+        @state.conditional_capture
+      end
+
+      # keep track of state.
+      def set_state (pState)
+        @previousState.push(@state)
+        @state = pState
+      end
+
+    protected
+
+      @languageType
+      @source
+      
+  # End class
+  end
+
+# End module
+end

data/lib/kuniri/language/language_factory.rb

@@ -0,0 +1,48 @@
+require_relative 'language'
+require_relative 'ruby/ruby_syntax'
+require_relative '../error/language_error'
+
+module Languages
+
+  # Simple factory to create language objects.
+  class LanguageFactory
+
+    # Handling the class creation.
+    # @param pType [String] Type of object
+    # @return Return an object of language.
+    def get_language(pType)
+      pType.downcase!
+
+      if pType == "ruby"
+        return Languages::RubySyntax.new
+      end
+      if pType == "python"
+        raise Error::LanguageError
+      end
+      if pType == "vhdl"
+        raise Error::LanguageError
+      end
+      if pType == "c"
+        raise Error::LanguageError
+      end
+      if pType == "cplusplus"
+        raise Error::LanguageError
+      end
+      if pType == "java"
+        raise Error::LanguageError
+      end
+      if pType == "assemblyarm"
+        raise Error::LanguageError
+      end
+      if pType == "php"
+        raise Error::LanguageError
+      else
+        raise Error::LanguageError
+      end
+    end
+
+  # Class
+  end
+
+# Module
+end

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

@@ -0,0 +1,134 @@
+require_relative '../abstract_container/structured_and_oo/attribute'
+require_relative '../container_data/structured_and_oo/attribute_data'
+require_relative '../../util/html_logger'
+require_relative '../../core/setting'
+
+module Languages
+
+  module Ruby
+
+    # Ruby Handling Ruby attributes
+    class AttributeRuby < Languages::Attribute
+
+      public
+
+        def initialize
+          @log = @settings = Kuniri::Setting.create.log
+          @attributeList = []
+        end
+
+        # Get ruby attribute. 
+        # @param pLine Verify if line has a ruby attribute.
+        # @return Return AttributeData or nil.
+        def get_attribute(pLine)
+          result = detect_attribute(pLine)
+          return nil unless result
+
+          @log.write_log("Info: Prepare to get attribute.")
+
+          listOfAttributes = []
+
+          # Has comma? Split string by comma
+          result = remove_unnecessary_information(result)
+
+          # Separated by comma, equal or the common case
+          if result.scan(/,/).count >= 1
+            listOfAttributes = handle_multiple_declaration_with_comma(result)
+            @log.write_log("Debug: Declared with comma: #{listOfAttributes}")
+          elsif result.scan(/=/).count > 1
+            listOfAttributes = handle_multiple_declaration_with_equal(result)
+            @log.write_log("Debug: separed by comma: #{listOfAttributes}")
+          else
+            listOfAttributes = handle_line_declaration(result)
+            @log.write_log("Debug: One line declaration #{listOfAttributes}")
+          end
+
+          return listOfAttributes
+        end
+
+    protected
+
+      # Override
+      def detect_attribute(pLine)
+        regexExp = /^\s*(?:@|attr_(?:accessor|read|write))(.*)$/
+        return nil unless pLine =~ regexExp
+        return pLine.scan(regexExp)[0].join("")
+      end
+
+      # 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)
+          attribute = Languages::AttributeData.new(variable)
+          listOfAttributes.push(attribute)
+        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 = Languages::AttributeData.new(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 = Languages::AttributeData.new(pString)
+        listOfAttributes.push(attribute)
+
+        return listOfAttributes
+      end
+
+    private
+
+      @log
+      @attributeList
+
+    #Class
+    end
+
+  # Ruby
+  end
+#Language
+end

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

@@ -0,0 +1,83 @@
+require_relative '../abstract_container/structured_and_oo/class'
+require_relative '../container_data/structured_and_oo/class_data'
+require_relative '../../util/html_logger'
+require_relative '../../core/setting'
+
+module Languages
+
+  module Ruby
+
+    # Class responsible for handling ruby classes.
+    class ClassRuby < Languages::Class
+
+      public
+
+        def initialize
+          @log = @settings = Kuniri::Setting.create.log
+        end
+
+        # Get ruby class.
+        # @see Languages::Class
+        def get_class(pLine)
+          result = detect_class(pLine)
+          return nil unless result
+
+          @log.write_log("Info: Detect class")
+
+          classCaptured = Languages::ClassData.new
+
+          inheritance = get_inheritance(result)
+          classCaptured.inheritances = inheritance if inheritance
+
+          result = prepare_final_string(result)
+          classCaptured.name = result
+
+          @log.write_log("Debug: Class: #{classCaptured.name}")
+
+          return classCaptured
+        end
+
+      protected
+
+        # Override
+        def detect_class(pLine)
+          regexExpression = /^\s*class\s+(.*)/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression)[0].join("")
+        end
+
+        # Override
+        def get_inheritance(pString)
+          if pString =~ /</
+            partial = pString.scan(/<(.*)/)
+            return remove_unnecessary_information(partial)
+          end
+          return nil
+        end
+
+        # Override
+        def remove_unnecessary_information(pString)
+          return pString.gsub(/\s|</, "") if pString =~ /\s|</
+          return pString
+        end
+
+        def prepare_final_string(pString)
+          if pString =~ /\s|</
+            partial = pString.gsub(/<.*/,"")
+            return remove_unnecessary_information(partial)
+          end
+          return pString
+        end
+
+    private
+
+      @log
+
+    # class
+    end
+  
+  # Ruby
+  end
+
+# Languages
+end

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

@@ -0,0 +1,84 @@
+require_relative '../abstract_container/structured_and_oo/comment'
+
+module Languages
+
+  module Ruby
+
+    # CommentRuby is responsible for handling ruby comments.
+    class CommentRuby < Languages::Comment
+
+      public
+
+        @flagMultipleLine
+
+        def initialize
+          @flagMultipleLine = false
+        end
+
+        # @see Comment
+        def get_comment(pLine)
+
+          # Single line
+          return pLine.scan(/#(.*)/)[0].join if is_single_line_comment?(pLine)
+
+          # Multiple line
+          multipleLine = handle_multiple_line(pLine)
+          return multipleLine if multipleLine
+          return nil
+        end
+
+        # @see Comment
+        def is_single_line_comment?(pLine)
+          return true if pLine =~ /#(.*)/
+          return false
+        end
+
+        # @see Comment
+        def is_multiple_line_comment?(pLine)
+          return true if (pLine =~ /^=begin(.*?)/ || @flagMultipleLine)
+          return false
+        end
+
+        # @see Comment
+        def is_multiple_line_comment_end?(pLine)
+          return true if pLine =~ /^=end/
+          return false
+        end
+
+      protected
+
+        # @see Comment
+        def prepare_line_comment(pString)
+          return "" if pString =~ /=begin/
+          return pString
+        end
+
+      private
+
+        def handle_multiple_line(pLine)
+          if is_multiple_line_comment_end?(pLine)
+            @flagMultipleLine = false
+            return ""
+          end
+
+          if @flagMultipleLine
+            pLine = prepare_line_comment(pLine)
+            return pLine
+          end
+
+          if is_multiple_line_comment?(pLine)
+            @flagMultipleLine = true
+            return ""
+          end
+
+          return nil
+        end
+
+    # class
+    end
+
+  # module
+  end
+
+# module
+end

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

@@ -0,0 +1,77 @@
+require_relative '../abstract_container/structured_and_oo/conditional'
+require_relative '../container_data/structured_and_oo/conditional_data'
+
+module Languages
+
+  module Ruby
+
+    # Class responsible for handling ruby conditional statements.
+    class ConditionalRuby < Languages::Conditional
+
+      public
+
+        # Get ruby conditional.
+        # @see Languages::Conditional
+        def get_conditional(pLine)
+          result = detect_conditional(pLine)
+          return nil unless result
+
+          conditionalCaptured = Languages::ConditionalData.new
+          conditionalCaptured.type = conditional_type(pLine)
+
+          conditionalCaptured.expression = get_expression(result)
+
+          return conditionalCaptured
+        end
+
+      protected
+
+        # Override.
+        def detect_conditional(pLine)
+          regexExp = /^\s*if\s+(.*)/
+          return pLine.scan(regexExp)[0].join("") if regexExp =~ pLine
+
+          regexExp = /^\s*case\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
+
+          return nil
+        end
+
+        # Override
+        def conditional_type(pString)
+          regexExp = /^\s+if|^if/
+          return "IF" if regexExp =~ pString
+
+          regexExp = /^\s+case|^case/
+          return "CASE" if regexExp =~ pString
+
+          regexExp = /^\s+unless|^unless/
+          return "UNLESS" if regexExp =~ pString
+
+          regexExp = /^\s+elsif|^elsif/
+          return "ELSIF" 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/constructor_ruby.rb

@@ -0,0 +1,36 @@
+require_relative '../abstract_container/structured_and_oo/constructor'
+require_relative '../container_data/structured_and_oo/constructor_data'
+require_relative 'function_behavior_ruby'
+
+module Languages
+
+  module Ruby
+
+    # Handling ruby constructor
+    class ConstructorRuby < Languages::Ruby::FunctionBehaviorRuby
+
+      public
+
+        # Get Ruby constructor.
+        # @see FunctionBehaviorRuby
+        def get_constructor(pLine, type = 'public')
+          result = get_function(pLine)
+          return nil unless result
+
+          if result.name =~ /initialize/
+            result.type = "CONSTRUCTOR"
+          else
+            return nil
+          end
+
+          return result
+        end
+
+    # Class
+    end
+
+  # Ruby
+  end
+
+# Language
+end