kuniri 0.0.1 → 0.2

data/Gemfile

@@ -3,12 +3,13 @@ source 'https://rubygems.org'
 gemspec
 
 group :development do
-  gem 'guard-rspec', '~> 4.2.10'
-  gem 'nokogiri', '~> 1.6.6'
+  gem 'coveralls', require: false
+  gem 'rspec', '~> 3.1.0'
 end
 
 group :test do
   gem 'coveralls', require: false
-  gem "codeclimate-test-reporter", group: :test, require: nil
+  gem 'codeclimate-test-reporter', group: :test, require: nil
   gem 'rspec', '~> 3.1.0'
+  gem 'libxml-ruby'
 end

data/README.md

@@ -1,7 +1,5 @@
 # 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)
@@ -11,14 +9,16 @@
 [![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)
+[![Gem Version](https://badge.fury.io/rb/kuniri.svg)](http://badge.fury.io/rb/kuniri)
+[![License](https://img.shields.io/badge/license-LGPLv3-green.svg)](https://github.com/Kuniri/kuniri/blob/master/COPYING)
 
 ----
 # What is Kuniri?
 
+<img src="https://github.com/kuniri/kuniri/wiki/logo/256px/with_round_border.png" alt="Kuniri" align="left" />
 > 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,
+tool for other tools, like a 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
@@ -36,67 +36,97 @@ 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
+> Kuniri is an Esperanto word which 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)
+* System Dependencies
  * 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:
 
-Kuniri can be installed with:
 ```
 rake install
 ```
 
-After installing you can check the commands with
+> After installing you can check the commands with:
+
 ```
 kuniri -h
 ```
 
+> Or you can install the stable version with:
+
+```
+gem install kuniri
+```
+
 ----
 # 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:
+
+> You have two different approaches to using kuniri: command line and
+configuration file.
+
+## Command line
+
+> Command line is the practical and easy way to use kuniri. You just have to
+use a similar command as the one described below:
 
 ```
-language:ruby
-source:lib/
-output:bin/
-extract:uml
+kuniri path/to/your/source/code -o path/to/kuniri/output -l ruby
 ```
 
-Finally, you can run Kuniri in your project and extract the information with:
+> First parameter is the source code path. ***"-o"***, means ***"output"*** and
+you can indicate the path that you want to put the final output. Finally
+***-l***, indicate which kind of language your project is.
+
+## Using configuration file
+
+> If you chose to use a configuration file, first you have to create
+".kuniri.yml" file. The example below shows the basic syntax:
+
+```
+:language: ruby
+:source: lib/
+:output: bin/
+```
+
+> First parameter, ***"language"***, indicates what kind of language kuniri
+will parse (unfortunately, we just have ruby language now). Second parameter
+is ***"source"***, and it is used for specifying the target folder to be parsed
+by kuniri. Finally the third parameter is ***"output"***, and you can use it to
+indicate which folder kuniri will put the final output.
+
+> Finally, you can execute kuniri with the command below:
 
 ```
 kuniri -e [file_name_output.xml]
 ```
 
--e means "extract mode". After you entered into iterative mode you can type:
+***-e*** means "extract mode".
+
+# How to contact us?
+
+You can contact us by:
+
+1. Mailing list: https://groups.google.com/forum/#!forum/kuniri
+2. Gitter: https://gitter.im/rodrigosiqueira/kuniri
+3. Irc: Connect to freenode, at kuniri
 
 ----
 # Author
 
 * Rodrigo Siqueira de Melo
- * rodrigosiqueiramelo@gmail.com
+ * siqueira@kuniri.org
 * Gustavo Jaruga
- * darksshades@hotmail.com
+ * jaruga@kuniri.org

data/Rakefile

@@ -8,6 +8,7 @@ RSpec::Core::RakeTask.new('spec')
 task :default => :spec
 
 namespace :parser do |args|
+
   desc 'Creates a new parser for kuniri with parser:create'
   task :create do
     options = {}
@@ -22,7 +23,8 @@ namespace :parser do |args|
     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}"
+      puts "Error: A folder for this parser code already exists at" +
+            "lib/kuniri/language/#{parsername.downcase}"
       exit 1
     end
 

data/bin/kuniri

@@ -3,51 +3,75 @@
 require 'kuniri'
 require 'optparse'
 require 'kuniri/core/kuniri'
-require 'kuniri/parser/parser_xml'
+require 'kuniri/parser/xml_output_format'
 
-options = {}
+@options = {}
+@options[:source] = ARGV[0]
 
-OptionParser.new do |opts|
-  opts.banner = "Usage: example.rb [options]"
-  opts.version = Kuniri::VERSION
+optionParser = OptionParser.new do |buildOptions|
+  buildOptions.banner = "Usage: optionParser PATH [OPTIONS]"
+  buildOptions.version = Kuniri::VERSION
 
-  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
-    options[:verbose] = v
+  buildOptions.on("-v", "--[no-]verbose", "Run verbosely") do |verboseMode|
+    @options[:verbose] = verboseMode
   end
 
-  opts.on("--version", "Show Kuniri version") do |v|
-    puts opts.ver
+  buildOptions.on("--version", "Show Kuniri version") do |version|
+    puts buildOptions.version
     exit
   end
 
-  opts.on("-i", "Iterative mode") do |v|
-    puts "Iterative mode..."
-    kuniri = Kuniri::Kuniri.new
-    kuniri.run_analysis
-    kuniri.start_navigation_mode
+  buildOptions.on("-o", "--output [DEST]", "Export") do |dest|
+    @options[:output] = dest
   end
 
-  opts.on("-p", "Parse project") do |v|
-    puts "PARSER..."
+  buildOptions.on("-O1", "--optimization 1,2,3", "Optimize", Numeric) do
+    |optimization|
+      @options[:optimization] = optimization
   end
 
-  opts.on("-e", "--export [FILENAME]", "Export XML") do |f|
-    puts "Exporting XML..."
-    if(f)
-      options[:filename] = f
+  buildOptions.on("-l", "--language [languageType]", "Define language") do
+    |languageType|
+    @options[:languageType] = languageType
+  end
+
+  buildOptions.on("-e", "--export [FILENAME]", "Export XML") do
+    |configurationFile|
+
+    puts "Exporting..."
+
+    if(configurationFile)
+      path = configurationFile
     else
-      options[:filename] = 'kuniri.xml'
+      path = '.kuniri.yml'
     end
 
     kuniri = Kuniri::Kuniri.new
+    kuniri.read_configuration_file(path)
     kuniri.run_analysis
 
-    parser = Parser::XML.new
-    parser.set_path(options[:filename])
-    parser.create_all_data kuniri.get_parser()
+    parser = Parser::XMLOutputFormat.new
+    parser.create_all_data(kuniri.get_parser())
   end
 
 end.parse!
 
-p options
-p ARGV
+def startParser
+  puts "Exporting ..."
+  unless (@options[:output])
+    @options[:output] = 'outputKuniri/'
+  end
+
+  kuniri = Kuniri::Kuniri.new
+  kuniri.set_configuration(@options[:source], @options[:languageType],
+                          @options[:output], @options[:optimization])
+  kuniri.run_analysis
+
+  parser = Parser::XMLOutputFormat.new
+  parser.set_path(@options[:output])
+  parser.create_all_data(kuniri.get_parser())
+end
+
+if @options[:source] && @options[:output]
+  startParser
+end

data/data/aggregation_lang.rb

@@ -0,0 +1,33 @@
+require_relative '../abstract_container/structured_and_oo/aggregation'
+require_relative '../../core/setting'
+require_relative '../container_data/structured_and_oo/aggregation_data'
+
+module Languages
+
+  module {LANG}
+
+    # {LANG} handling aggregation
+    class Aggregation{LANG} < Languages::Aggregation
+
+      public
+
+        # @param pLine Verify if line has a {LANG} aggregation.
+        # @return Return string or nil.
+        def get_aggregation(pLine)
+          # YOUR CODE HERE
+        end
+
+    protected
+
+      # Override
+      def detect_aggregation(pLine)
+        # YOUR CODE HERE
+      end
+
+    #Class
+    end
+
+  # {LANG}
+  end
+#Language
+end

data/data/attribute_lang.rb

@@ -1,127 +1,54 @@
-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 '../abstract_container/structured_and_oo/attribute'
+require_relative '../container_data/structured_and_oo/attribute_data'
 require_relative '../../core/setting'
 
 module Languages
-  # @module {LANG} Handling {LANG} attributes
+
   module {LANG}
 
-    # Handle {LANG} attribute
+    # Handling {LANG} attributes
     class Attribute{LANG} < Languages::Attribute
 
       public
 
         def initialize
-          @log = @settings = Kuniri::Setting.create.log
-          @attributeList = []
+          # YOUR CODE HERE
         end
 
+        # Get {LANG} attribute.
+        # @param pLine Verify if line has a {LANG} 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
+          # YOUR CODE HERE
         end
 
     protected
 
       # Override
       def detect_attribute(pLine)
-        regexExp = /^\s*(?:@|attr_(?:accessor|read|write))(.*)$/
-        return nil unless pLine =~ regexExp
-        return pLine.scan(regexExp)[0].join("")
+        # YOUR CODE HERE
       end
 
       # Override
       def remove_unnecessary_information(pString)
-        return pString.gsub!(/\(.*\)/,"") if pString =~ /\(.*\)/
-        return pString
+        # YOUR CODE HERE
       end
 
       # Override
       def prepare_final_string(pString)
-        if pString =~ /\s+|:|@|=/
-          return pString.gsub!(/\s+|:|@|=/,"")
-        end
-        return pString
+        # YOUR CODE HERE
       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
+        # YOUR CODE HERE
       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
+        # YOUR CODE HERE
       end
 
-    private
-
-      @log
-      @attributeList
-
     #Class
     end