kuniri 0.0.1

data/Guardfile

@@ -0,0 +1,8 @@
+# Guardfile
+guard 'rspec', cmd: "bundle exec rspec", :all_after_pass => false, 
+  :failed_mode => :none do
+  watch(%r{\Aspec/.+_spec\.rb\z})
+  watch(%r{\Aapp/(.+)\.rb\z})   { |m| "spec/app/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -0,0 +1,102 @@
+# KUNIRI
+
+![alt text](https://github.com/kuniri/kuniri/wiki/logo/256px/with_round_border.png "Kuniri")
+
+----
+
+[![Join the chat at https://gitter.im/rodrigosiqueira/kuniri](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/rodrigosiqueira/kuniri?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+[![Build Status](https://travis-ci.org/Kuniri/kuniri.svg?branch=master)](https://travis-ci.org/Kuniri/kuniri)
+[![Code Climate](https://codeclimate.com/github/Kuniri/kuniri/badges/gpa.svg)](https://codeclimate.com/github/Kuniri/kuniri)
+[![Stories in Ready](https://badge.waffle.io/Kuniri/kuniri.svg?label=ready&title=Ready)](http://waffle.io/Kuniri/kuniri)
+[![Coverage Status](https://coveralls.io/repos/Kuniri/kuniri/badge.svg?branch=master&service=github)](https://coveralls.io/github/Kuniri/kuniri?branch=master)
+[![Inline docs](http://inch-ci.org/github/Kuniri/kuniri.svg?branch=master)](http://inch-ci.org/github/Kuniri/kuniri)
+[![License](https://img.shields.io/badge/license-GPLv3-green.svg)](https://github.com/Kuniri/kuniri/blob/master/COPYING)
+
+----
+# What is Kuniri?
+
+> Briefly, the main goal of Kuniri is: parse any kind of language, and generate
+a common model file with code information. We believe that Kuniri can be a base
+tool for other tools, like diagram generator, traceability, code quality,
+documentation, and so forth. Initially, the main objective of Kuniri was to
+provide a way to dynamically generate diagrams and traceability based on code.
+However, the parser proved much more useful for many other kinds of
+applications; thus, the focus shifted to the parser creation.
+
+> Kuniri will inspect the source code, and extract information to generate a
+final output. This file is a XML file (and other types in the near future), and
+follows a strong pattern. This feature gives flexibility to other tools read the
+file and process anything they want.
+
+> Additionally, Kuniri was designed to grow to two main directions: support for
+different languages, and provide ways to select which kind of information to
+extract from the code.
+
+----
+## What is the the meaning of "kuniri"?
+
+> Kuniri is an Esperanto word, that means "go with" or "follow". This name was
+chosen because of the idea to keep following your code project with diagrams,
+traceability, code quality and others.
+
+----
+# Development
+
+* System Dependencies (Kubuntu/Ubuntu)
+ * YARD 0.8
+ * RSpec 3.1.7
+ * Rake 10.4
+ * Guard-rspec 4.2
+ * nokogiri 1.6.6
+* Ruby version: 2.1
+* Run test suit
+ * rake or spec
+* YARD documentation
+ * yardoc
+
+----
+# Install
+
+First of all, you have to install all the required gems.
+```
+bundle install
+```
+
+Kuniri can be installed with:
+```
+rake install
+```
+
+After installing you can check the commands with
+```
+kuniri -h
+```
+
+----
+# How to use
+If you want to use kuniri in your project, first you have to create ".kuniri"
+file. The example below show the basic syntax:
+
+```
+language:ruby
+source:lib/
+output:bin/
+extract:uml
+```
+
+Finally, you can run Kuniri in your project and extract the information with:
+
+```
+kuniri -e [file_name_output.xml]
+```
+
+-e means "extract mode". After you entered into iterative mode you can type:
+
+----
+# Author
+
+* Rodrigo Siqueira de Melo
+ * rodrigosiqueiramelo@gmail.com
+* Gustavo Jaruga
+ * darksshades@hotmail.com

data/Rakefile

@@ -0,0 +1,114 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'optparse'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec
+
+namespace :parser do |args|
+  desc 'Creates a new parser for kuniri with parser:create'
+  task :create do
+    options = {}
+    OptionParser.new(args) do |opts|
+      opts.banner = "Usage: rake user:create [parser_name]"
+    end.parse!
+
+    if ARGV.length <= 1 then
+      puts 'Must use pass a parser name'
+      exit 0
+    end
+    parsername = ARGV[1]
+
+    if File.directory?("lib/kuniri/language/#{parsername.downcase}") then
+      puts "Error: A folder for this parser code already exists at lib/kuniri/language/#{parsername.downcase}"
+      exit 1
+    end
+
+    FileUtils.mkdir_p("lib/kuniri/language/#{parsername.downcase}")
+    Dir.glob( 'data/*.rb' ).select { |f| File.file?( f ) }.each do |f|
+      fdest = File.basename(f).gsub('lang', parsername.downcase)
+      dest = "lib/kuniri/language/#{parsername.downcase}/#{fdest}"
+      FileUtils.cp( f, dest )
+      p dest
+    end
+
+    Dir.glob( "lib/kuniri/language/#{parsername.downcase}/*.rb" ).select { |f| File.file?( f ) }.each do |f|
+      text = File.read(f)
+      formated_text = text.gsub('{LANG}', parsername.capitalize)
+      formated_text = formated_text.gsub('{lang}', parsername.downcase)
+      File.open(f, "w") { |file| file << formated_text }
+    end
+
+    f = 'lib/kuniri/language/language_factory.rb'
+    text = File.read(f)
+    relative = "require_relative '#{parsername.downcase}/#{parsername.downcase}_syntax'"
+
+    if text.include?(relative) then
+      puts "Error: the /lib/kuniri/language/language_factory.rb file already has the require for this parser"
+      exit 1
+    end
+
+    formated_text = relative + "\n" + text
+
+    condition = "pType.downcase!
+
+      if pType == '#{parsername.downcase}'
+        return Languages::#{parsername.capitalize}Syntax.new
+      end"
+
+    formated_text = formated_text.gsub("pType.downcase!\n", condition)
+    File.open(f, "w") { |file| file << formated_text }
+
+    exit 0
+  # End task parser:create
+  end
+
+  desc 'Removes a parser for kuniri with parser:remove'
+  task :remove do
+    options = {}
+    OptionParser.new(args) do |opts|
+      opts.banner = "Usage: rake user:remove [parser_name]"
+    end.parse!
+
+    if ARGV.length <= 1 then
+      puts 'Must use pass a parser name'
+      exit 0
+    end
+    parsername = ARGV[1]
+
+    input = ''
+    STDOUT.puts "This operation will delete all code related to the #{parsername} parser, are you sure(y/n)?"
+    input = STDIN.gets.chomp
+    exit 0 unless input.downcase == "y" or input.downcase == "yes"
+
+    if !File.directory?("lib/kuniri/language/#{parsername.downcase}") then
+      puts "Error: A folder for this parser code does not exists at lib/kuniri/language/#{parsername.downcase}"
+      exit 1
+    end
+
+    FileUtils.rm_rf("lib/kuniri/language/#{parsername.downcase}")
+
+    f = 'lib/kuniri/language/language_factory.rb'
+    text = File.read(f)
+    relative = "require_relative '#{parsername.downcase}/#{parsername.downcase}_syntax'\n"
+
+    if not text.include?(relative) then
+      puts "Warning: the /lib/kuniri/language/language_factory.rb file could not found the require for this parser"
+    end
+
+    formated_text = text.gsub(relative,'')
+
+    condition = "\n      if pType == '#{parsername.downcase}'
+        return Languages::#{parsername.capitalize}Syntax.new
+      end"
+
+    formated_text = formated_text.gsub(condition, '')
+    File.open(f, "w") { |file| file << formated_text }
+    exit 0
+
+  # End task parser:remove
+  end
+end
+

data/bin/kuniri

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'kuniri'
+require 'optparse'
+require 'kuniri/core/kuniri'
+require 'kuniri/parser/parser_xml'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: example.rb [options]"
+  opts.version = Kuniri::VERSION
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("--version", "Show Kuniri version") do |v|
+    puts opts.ver
+    exit
+  end
+
+  opts.on("-i", "Iterative mode") do |v|
+    puts "Iterative mode..."
+    kuniri = Kuniri::Kuniri.new
+    kuniri.run_analysis
+    kuniri.start_navigation_mode
+  end
+
+  opts.on("-p", "Parse project") do |v|
+    puts "PARSER..."
+  end
+
+  opts.on("-e", "--export [FILENAME]", "Export XML") do |f|
+    puts "Exporting XML..."
+    if(f)
+      options[:filename] = f
+    else
+      options[:filename] = 'kuniri.xml'
+    end
+
+    kuniri = Kuniri::Kuniri.new
+    kuniri.run_analysis
+
+    parser = Parser::XML.new
+    parser.set_path(options[:filename])
+    parser.create_all_data kuniri.get_parser()
+  end
+
+end.parse!
+
+p options
+p ARGV

data/data/attribute_lang.rb

@@ -0,0 +1,131 @@
+require_relative '../abstract_container/structured_and_oo/attribute.rb'
+require_relative '../container_data/structured_and_oo/attribute_data.rb'
+require_relative '../../util/html_logger'
+require_relative '../../core/setting'
+
+module Languages
+  # @module {LANG} Handling {LANG} attributes
+  module {LANG}
+
+    # Handle {LANG} attribute
+    class Attribute{LANG} < Languages::Attribute
+
+      public
+
+        def initialize
+          @log = @settings = Kuniri::Setting.create.log
+          @attributeList = []
+        end
+
+        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
+
+  # {LANG}
+  end
+#Language
+end

data/data/class_lang.rb

@@ -0,0 +1,77 @@
+require_relative '../abstract_container/structured_and_oo/class.rb'
+require_relative '../container_data/structured_and_oo/class_data.rb'
+require_relative '../../util/html_logger'
+require_relative '../../core/setting'
+
+module Languages
+
+  module {LANG}
+
+    class Class{LANG} < Languages::Class
+
+      public
+
+        def initialize
+          @log = @settings = Kuniri::Setting.create.log
+        end
+
+        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
+
+        def detect_class(pLine)
+          regexExpression = /^\s*class\s+(.*)/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression)[0].join("")
+        end
+
+        def get_inheritance(pString)
+          if pString =~ /</
+            partial = pString.scan(/<(.*)/)
+            return remove_unnecessary_information(partial)
+          end
+          return nil
+        end
+
+      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
+
+  # {LANG}
+  end
+
+# Languages
+end

data/data/conditional_lang.rb

@@ -0,0 +1,71 @@
+require_relative '../abstract_container/structured_and_oo/conditional.rb'
+require_relative '../container_data/structured_and_oo/conditional_data.rb'
+
+module Languages
+
+  module {LANG}
+
+    class Conditional{LANG} < Languages::Conditional
+
+      public
+
+        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
+
+        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
+
+        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
+
+        def get_expression(pString)
+          leftStrip = pString.lstrip
+          rightStrip = leftStrip.rstrip
+          return rightStrip
+        end
+
+    # Class
+    end
+
+  # {LANG}
+  end
+
+# Module
+end

data/data/constructor_lang.rb

@@ -0,0 +1,34 @@
+require_relative '../abstract_container/structured_and_oo/constructor'
+require_relative '../container_data/structured_and_oo/constructor_data'
+require_relative 'function_behavior_{lang}'
+
+module Languages
+
+  module {LANG}
+
+    # Handling {LANG} constructor
+    class ConstructorRuby < Languages::{LANG}::FunctionBehavior{LANG}
+
+      public
+
+        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
+
+  # {LANG}
+  end
+
+# Language
+end

data/data/end_block_lang.rb

@@ -0,0 +1,30 @@
+require_relative '../abstract_container/structured_and_oo/end_block'
+
+module Languages
+
+  module {LANG}
+
+    class EndBlockRuby < Languages::EndBlock
+
+      public
+
+        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
+
+  # {LANG}
+  end
+
+# Module
+end

data/data/extern_requirement_lang.rb

@@ -0,0 +1,45 @@
+require_relative '../abstract_container/structured_and_oo/extern_requirement'
+require_relative '../container_data/structured_and_oo/extern_requirement_data'
+
+module Languages
+
+  module {LANG}
+
+    # @class ExternRequirement Handling extern requirements.
+    class ExternRequirement{LANG} < Languages::ExternRequirement
+
+      public
+
+        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
+
+        def detect_extern_requirement(pLine)
+          regexExpression = /^\s*require(?:_relative)?\s+('|")(.*)\1/
+          return nil unless pLine =~ regexExpression
+          return pLine.scan(regexExpression).join("")
+        end
+
+        def remove_unnecessary_information(pLine)
+          regexClean = /\s+|"|'/
+          return pLine.gsub!(regexClean, "") if pLine =~ regexClean
+          return pLine
+        end
+
+    # Class
+    end
+
+  # {LANG}
+  end
+
+# Module
+end