kuniri 0.0.1

data/lib/kuniri/language/abstract_container/structured_and_oo/variable_behaviour.rb

@@ -0,0 +1,53 @@
+module Languages
+
+  # @abstract This class is an abstraction for handling any element whose the
+  # behaviour is similar to a variable. As an example, we have global
+  # variables and attributes that have some similarities.
+  class VariableBehaviour
+
+    protected
+
+      # Remove unnecessary information from line. For example, remove
+      # everything into parenthesis or line comment.
+      # @param pString String for remove unnecessary information.
+      # @return If match any unnecessary character defined by the programmer
+      #         returns the new string, otherwise return the same string.
+      def remove_unnecessary_information(pString)
+        raise NotImplementedError
+      end
+
+      # Prepare final string, before save it in a container data.
+      # @param pLine Line to be inspected.
+      # @return Return a string.
+      def prepare_final_string(pLine)
+        raise NotImplementedError
+      end
+
+      # One common behaviour related with variables, is the multiple
+      # declaration separated by comma. This method is responsible for
+      # handling multiple line declaration separated by comma.
+      # @param pString String to be handled.
+      # @return Return an array with multiple variables.
+      def handle_multiple_declaration_with_comma(pString)
+        raise NotImplementedError
+      end
+
+      # Handling multiple declaration with equal.
+      # @param pString String with multiple declaration.
+      # @return Return an string.
+      def handle_multiple_declaration_with_equal(pString)
+        raise NotImplementedError
+      end
+
+      # Handling line declaration.
+      # @param pString Line with simple declaration.
+      # @return Return a string.
+      def handle_line_declaration(pString)
+        raise NotImplementedError
+      end
+
+  # Class
+  end
+
+# Language
+end

data/lib/kuniri/language/abstract_container/structured_and_oo/variable_global.rb

@@ -0,0 +1,67 @@
+module Languages
+
+  # @abstract Any global variable should be handler here.
+  class VariableGlobal
+
+      public
+
+        # This method is the main interface for extract data from specific
+        # code and convert it to a common representation.
+        # @param pLine Line to be inspected.
+        # @return If line has a variable, this method returns an object of
+        #       VariableGlobalData. Otherwise returns nil.
+        # @see variable_global_data.rb
+        def get_variable(pLine)
+          raise NotImplementedError
+        end
+
+      protected
+
+        # Verify if line has a variable.
+        # @param pLine String to be analysed.
+        # @return Returns a partial string, if it can be a variable. Otherwise
+        #       return nil.
+        def detect_variable(pLine)
+          raise NotImplementedError
+        end
+
+        # Remove unnecessary information.
+        # @param pLine String to be improved.
+        # @return Return an partial string, or the same if no work is needed.
+        def remove_unnecessary_information(pLine)
+          raise NotImplementedError
+        end
+
+        # Make some prunes and adjustments in the string.
+        # @param pLine String to be prepared.
+        # @return Return a string.
+        def prepare_final_string(pLine)
+          raise NotImplementedError
+        end
+
+        # Handling multiple line declaration with comma.
+        # @param pString String with multiple declaration with comma.
+        # @return Return a string.
+        def handle_multiple_declaration_with_comma(pString)
+          raise NotImplementedError
+        end
+
+        # Handling multiple declaration with equal.
+        # @param pString String to be handled.
+        # @return Return an array with all variables.
+        def handle_multiple_declaration_with_equal(pString)
+          raise NotImplementedError
+        end
+
+        # Handling simple line declaration.
+        # @param pString String with simple declaration.
+        # @return Return a string.
+        def handle_line_declaration(pString)
+          raise NotImplementedError
+        end
+
+  # class
+  end
+
+# module
+end

data/lib/kuniri/language/container_data/structured_and_oo/attribute_data.rb

@@ -0,0 +1,26 @@
+require_relative 'basic_data'
+
+module Languages
+
+  # Handling attributes data.
+  class AttributeData < Languages::BasicData
+
+    public
+
+      # Basic initialization of attribute.
+      # @param pAttribute_name Attribute name for basic initialization.
+      def initialize (pAttribute_name)
+        @name = pAttribute_name
+        @visibility = "public"
+      end
+
+    private
+
+      # Type of the attribute.
+      @type
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/basic_data.rb

@@ -0,0 +1,18 @@
+module Languages
+
+  # @abstract Usually, all data in this container needs at list one
+  # information: name. This class aim to be a generic class for all elements
+  # of container data.
+  class BasicData
+
+    public
+
+      attr_accessor :name
+      attr_accessor :visibility
+      attr_accessor :comments
+
+  # class
+  end
+
+# module
+end

data/lib/kuniri/language/container_data/structured_and_oo/class_data.rb

@@ -0,0 +1,77 @@
+require_relative 'basic_data'
+require_relative 'attribute_data'
+require_relative 'method_data'
+require_relative 'constructor_data'
+
+module Languages
+
+  # Handling class information
+  class ClassData < Languages::BasicData
+
+    public
+
+      attr_accessor :inheritances
+      attr_reader :attributes
+      attr_reader :methods
+      attr_reader :constructors
+
+      def initialize
+        @inheritances = [] 
+        @attributes = []
+        @methods = []
+        @constructors = []
+        @visibility = "public"
+      end
+
+      # Add attribute to class data, notice the possibility of call this
+      # method more than one time.
+      # @param pAttribute Attribute to be added inside class. This attribute
+      #         is a list of AttributeData.
+      def add_attribute(pAttribute)
+        pAttribute.each do |attributeElement|
+          return unless attributeElement.is_a?(Languages::AttributeData)
+          @attributes.push(attributeElement)
+        end
+      end
+
+      # Add method inside ClassData. Remember the possibility of have zero or
+      # any method inside a class.
+      # @param pMethod It is an object of FunctionData with the method
+      #         informations.
+      def add_method(pMethod)
+        return unless pMethod.is_a?(Languages::FunctionData)
+
+        @methods.push(pMethod)
+      end
+
+      # Add constructor inside class.
+      # @param pConstructor Object of FunctionData to be added at class.
+      def add_constructor(pConstructor)
+        return unless pConstructor.is_a?(Languages::FunctionData)
+
+        @constructors.push(pConstructor)
+      end
+
+# TODO: REMOVE IT!
+      def get_methods
+        @methods
+      end
+
+      def get_attributes
+        @attributes
+      end
+
+      def get_constructors
+        @constructors
+      end
+
+      def get_parameters
+        @parameters
+      end
+
+  # Class
+  end
+
+# Module
+end
+

data/lib/kuniri/language/container_data/structured_and_oo/conditional_data.rb

@@ -0,0 +1,23 @@
+require_relative 'basic_data'
+
+module Languages
+
+  # Class responsible for handling conditional data
+  class ConditionalData < Languages::BasicData
+
+    public
+
+      attr_accessor :type
+      attr_accessor :expression
+
+      def initialize
+        @name = "nothing"
+        @type = "none"
+        @expression = "empty"
+      end
+
+  # class
+  end
+
+# module
+end

data/lib/kuniri/language/container_data/structured_and_oo/constructor_data.rb

@@ -0,0 +1,18 @@
+require_relative 'function_abstract'
+
+module Languages
+
+  # Handling constructor information.
+  class ConstructorData < Languages::FunctionAbstract
+
+    public
+
+      def initialize(pConstructorName)
+        super(pConstructorName)
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/extern_requirement_data.rb

@@ -0,0 +1,26 @@
+require_relative 'basic_data'
+
+module Languages
+
+  # ExternRequirementData Handling extern requirements
+  class ExternRequirementData < Languages::BasicData
+
+    public
+
+      attr_reader :path
+
+      def initialize(pRequirement)
+        @name = pRequirement
+      end
+
+      # Set path of extern requirement.
+      # @param pPath Path inside the extern requirement.
+      def setPath(pPath)
+        @path = pPath
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/file_element.rb

@@ -0,0 +1,77 @@
+require_relative 'basic_data'
+require_relative 'function_data'
+require_relative 'variable_global_data'
+require_relative 'extern_requirement_data'
+require_relative 'module_namespace_data'
+require_relative 'class_data'
+
+module Languages
+
+  # FileElement is the upper element related with container data, this class
+  # refers to file.
+  class FileElement < Languages::BasicData
+
+    public
+
+      attr_reader :global_functions
+      attr_reader :global_variables
+      attr_reader :extern_requirements
+      attr_reader :classes
+      attr_reader :modules
+
+      def initialize(pName)
+        @global_functions = []
+        @global_variables = []
+        @extern_requirements = []
+        @classes = []
+        @modules = []
+        @name = pName
+        @comments = ""
+      end
+
+      # Add global function to the file.
+      # @param pFunction An object of FunctionData to be added at the file.
+      def add_global_function(pFunction)
+        return if not pFunction.is_a?(Languages::FunctionData)
+
+        @global_functions.push(pFunction)
+      end
+
+      # Add global variable inside file.
+      # @param pVariable An VariableGlobalData object to be added.
+      def add_global_variable(pVariable)
+        pVariable.each do |element|
+          next unless element.is_a?(Languages::VariableGlobalData)
+          @global_variables.push(element)
+        end
+      end
+
+      # Add extern requirement inside file.
+      # @param pOutside Add an object of ExternRequirementData.
+      def add_extern_requirement(pOutside)
+        return unless pOutside.is_a?(Languages::ExternRequirementData)
+
+        @extern_requirements.push(pOutside)
+      end
+
+      # Add a class inside file.
+      # @param pClass Add an object of ClassData.
+      def add_class(pClass)
+        return unless pClass.is_a?(Languages::ClassData)
+
+        @classes.push(pClass)
+      end
+
+      # Add a module inside file.
+      # @param pModule Add an object of ModuleNamespaceData
+      def add_modules(pModule)
+        return unless pModule.is_a?(Languages::ModuleNamespaceData)
+
+        @modules.push(pModule)
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/function_abstract.rb

@@ -0,0 +1,52 @@
+require_relative 'basic_data'
+require_relative 'conditional_data'
+require_relative 'repetition_data'
+
+module Languages
+
+  # Abstraction for handling function data
+  class FunctionAbstract < Languages::BasicData
+
+    public
+
+      attr_reader :parameters
+      attr_reader :conditionals
+      attr_reader :repetitions
+      attr_accessor :type
+
+      def initialize(pFunctionName)
+        @name = pFunctionName
+        @parameters = []
+        @conditionals = []
+        @repetitions = []
+      end
+
+      # Add parameters inside function.
+      # @param pValue Add a parameter inside function.
+      def add_parameters(pValue)
+        # TODO: You have to fix it.
+        @parameters.push(pValue)
+      end
+
+      # Add conditional element inside function.
+      # @param pConditional An object of ConditionalData.
+      # @return If pConditional is not an instance of ConditionalData,
+      #         return nil.
+      def add_conditional(pConditional)
+        return nil unless (pConditional.instance_of?Languages::ConditionalData)
+        @conditionals.push(pConditional)
+      end
+
+      # Add repetition element inside function.
+      # @param pRepetition An object of RepetionData.
+      # @return If pRepetition is not RepetionData instance return nil.
+      def add_repetition(pRepetition)
+        return nil unless (pRepetition.instance_of?Languages::RepetitionData)
+        @repetitions.push(pRepetition)
+      end
+
+  # class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/function_data.rb

@@ -0,0 +1,21 @@
+require_relative 'function_abstract'
+
+module Languages
+
+  # Handle function data
+  class FunctionData < Languages::FunctionAbstract
+
+    public
+
+      attr_reader :parameters
+
+      def initialize(pFunctionName)
+        super(pFunctionName)
+        @visibility = "global"
+      end
+
+  # class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/method_data.rb

@@ -0,0 +1,20 @@
+require_relative 'function_abstract'
+
+module Languages
+
+  # Handling method informations
+  class MethodData < Languages::FunctionAbstract
+
+    public
+
+      attr_reader :parameters
+
+      def initialize(pMethod_name)
+        super(pMethod_name)
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/module_namespace_data.rb

@@ -0,0 +1,18 @@
+require_relative 'basic_data'
+
+module Languages
+
+  # Handling module data
+  class ModuleNamespaceData < Languages::BasicData
+
+    public
+
+      def initialize(pName)
+          @name = pName
+      end
+
+  # Class
+  end
+
+# Module
+end

data/lib/kuniri/language/container_data/structured_and_oo/repetition_data.rb

@@ -0,0 +1,23 @@
+require_relative 'basic_data'
+
+module Languages
+
+  # Class responsible for handling repetition data
+  class RepetitionData < Languages::BasicData
+
+    public
+
+      attr_accessor :type
+      attr_accessor :expression
+
+      def initialize
+        @name = "nothing"
+        @type = "none"
+        @expression = "empty"
+      end
+
+  # class
+  end
+
+# module
+end

data/lib/kuniri/language/container_data/structured_and_oo/variable_global_data.rb

@@ -0,0 +1,22 @@
+require_relative 'basic_data'
+
+module Languages
+
+  # Class responsible for handling global variables.
+  class VariableGlobalData < Languages::BasicData
+
+    public
+
+      attr_accessor :value
+      attr_accessor :type
+
+      def initialize(pName)
+        @name = pName
+        @visibility = "global"
+      end
+
+  # Class
+  end
+
+# Languages
+end