reconn 0.1.0

data/lib/reconn/view/view.rb

@@ -0,0 +1,277 @@
+require_relative '../analyzer.rb'
+require_relative '../visualizer.rb'
+
+class View
+
+	include GladeGUI
+
+	def before_show()
+    dialog_response, dialog = show_file_chooser_dialog
+    if dialog_response == Gtk::Dialog::RESPONSE_ACCEPT
+      analyzer = Analyzer::Analyzer.new
+      @classes, @methods, @smells = analyzer.analyze(dialog.filename)
+
+      @general_stats_view = build_general_stats_view
+      @builder['dataviewport'].add(@general_stats_view)
+    end
+    dialog.destroy
+	end
+
+#########################################
+  # On button clicked methods
+
+	def on_general_stats_button_clicked
+    clean_data_view
+
+    unless @general_stats_view
+      @general_stats_view = build_general_stats_view
+    end
+
+    @builder['dataviewport'].add(@general_stats_view)
+	end
+
+  def on_class_stats_button_clicked
+    clean_data_view
+
+    unless @class_stats_view
+      @class_stats_view = build_class_stats_view
+    end
+
+    @builder['dataviewport'].add(@class_stats_view)
+  end
+
+  def on_class_diag_button_clicked
+    clean_data_view
+
+    unless @class_diag_view
+      @class_diag_view = build_class_diag_view
+    end
+
+    @builder['dataviewport'].add(@class_diag_view)
+  end
+
+  def on_class_dep_button_clicked
+    clean_data_view
+
+    unless @class_dep_view
+      @class_dep_view = build_class_dep_view
+    end
+
+    @builder['dataviewport'].add(@class_dep_view)
+  end
+
+  def on_method_stats_button_clicked
+    clean_data_view
+
+    unless @method_stats_view
+      @method_stats_view = build_method_stats_view
+    end
+
+    @builder['dataviewport'].add(@method_stats_view)
+  end
+
+  def on_method_diag_button_clicked
+    clean_data_view
+
+    unless @method_diag_view
+      @method_diag_view = build_method_diag_view
+    end
+
+    @builder['dataviewport'].add(@method_diag_view)
+  end
+
+  def on_if_smell_button_clicked
+    clean_data_view
+
+    unless @if_smell_view
+      @if_smell_view = build_if_smell_view
+    end
+
+    @builder['dataviewport'].add(@if_smell_view)
+  end
+
+  def on_method_smell_button_clicked
+    clean_data_view
+
+    unless @method_smell_view
+      @method_smell_view = build_method_smell_view
+    end
+
+    @builder['dataviewport'].add(@method_smell_view)
+  end
+
+###########################################
+    # View builders
+
+  def build_general_stats_view
+    lines = 0
+    @methods.each do |method|
+      lines += method.lines
+    end
+
+    text_arr = ["Total number of classes: #{@classes.length} \n"]
+    text_arr << "Total number of methods: #{@methods.length} \n"
+    text_arr << "Total number of lines of code: #{lines} \n"
+
+    largest_class = @classes.sort_by {|c| c.lines}.pop
+
+    class_methodnum = Hash.new(0)
+    @classes.each do |klass|
+      class_methodnum.store(klass.name, klass.methods.size)
+    end
+    class_methodnum = class_methodnum.sort_by {|name, methods| methods}
+
+    text_arr << "\n"
+    text_arr << "Largest class: #{largest_class} \n"
+    text_arr << "Number of lines: #{largest_class.lines} \n"
+    text_arr << "\n"
+    text_arr << "Class with largest number of methods: #{class_methodnum.last[0]} \n"
+    text_arr << "Number of methods: #{class_methodnum.last[1]} \n"
+
+    largest_method = @methods.sort_by {|m| m.lines}.pop
+    text_arr << "\n"
+    text_arr << "Largest method: #{largest_method} \n"
+    text_arr << "Number of lines: #{largest_method.lines} \n"
+
+    build_text_view(text_arr.join)
+  end
+
+  def build_class_stats_view
+    features = [ {name: "Number of lines", data: prepare_data(@classes, :lines)} ]
+    features << {name: "Cyclomatic complexity", data: prepare_data(@classes, :complexity)}
+    features << {name: "Number of methods", data: prepare_data(@classes, :methods_number)}
+    text = prepare_text(features)
+    build_text_view(text)
+  end
+
+  def build_method_stats_view
+    features = [ {name: "Number of lines", data: prepare_data(@methods, :lines)} ]
+    features << {name: "Cyclomatic complexity", data: prepare_data(@methods, :complexity)}
+    text = prepare_text(features)
+    build_text_view(text)
+  end
+
+  def build_if_smell_view
+    text_arr = []
+    @smells.each {|s| text_arr << s.to_s + "\n" if s.type == :too_complex_method}
+    build_text_view(text_arr.join)
+  end
+
+  def build_method_smell_view
+    text_arr = []
+    @smells.each {|s| text_arr << s.to_s + "\n" if s.type == :too_big_method}
+    build_text_view(text_arr.join)
+  end
+
+  def build_text_view(text)
+    stats_view = Gtk::TextView.new
+    stats_view.editable = false
+    stats_view.cursor_visible = false
+    stats_view.buffer.text = text
+    stats_view.show
+    stats_view
+  end
+
+  def prepare_text(features)
+    text_arr = []
+    features.each do |feature|
+      text_arr << "#{feature[:name]}: \n"
+      data = feature[:data]
+      data.each_index do |i|
+        break if i == 30
+        item = data[i]
+        text_arr << "#{i+1}. #{item[:label]} => #{item[:value]} \n"
+      end
+      text_arr << "\n"
+    end
+    text_arr.join
+  end
+
+  def build_class_diag_view
+    diagrams = [ {title: "Lines of code", parameter: :lines} ]
+    diagrams << {title: "Cyclomatic complexity", parameter: :complexity}
+    diagrams << {title: "Number of methods", parameter: "methods_number"}
+    build_diag_view(@classes, diagrams)
+  end
+
+  def build_method_diag_view
+    diagrams = [ {title: "Lines of code", parameter: :lines} ]
+    diagrams << {title: "Cyclomatic complexity", parameter: :complexity}
+    build_diag_view(@methods, diagrams)
+  end
+
+  def build_diag_view(raw_data, diagrams)
+    tabbed_panel = Gtk::Notebook.new
+
+    diagrams.each do |diag|
+      data = prepare_data(raw_data, diag[:parameter])
+
+      title = diag[:title]
+
+      pie_chart = build_pie_chart(title, data)
+      bar_chart = build_bar_chart(title, data.first(10))
+
+      container = Gtk::VBox.new(false, 4)
+      container = container.pack_end(pie_chart)
+      container = container.pack_end(bar_chart)
+      container.show
+
+      tabbed_panel.append_page(container, Gtk::Label.new(title))
+    end
+
+    tabbed_panel.show
+  end
+
+  def build_pie_chart(title, data)
+    binary_chart = Visualizer.make_pie_chart(title, data, 4)
+    chart_to_image(binary_chart)
+  end
+
+  def build_bar_chart(title, data)
+    binary_chart = Visualizer.make_bar_chart(title, data)
+    chart_to_image(binary_chart)
+  end
+
+  def chart_to_image(binary_chart)
+    loader = Gdk::PixbufLoader.new("png")
+    loader.last_write(binary_chart)
+    chart = loader.pixbuf
+    Gtk::Image.new(chart).show
+  end
+#######
+  def build_class_dep_view
+    binary_chart = Visualizer.make_dependency_diagram(@classes)
+    loader = Gdk::PixbufLoader.new("png")
+    loader.last_write(binary_chart)
+    chart = loader.pixbuf
+    Gtk::Image.new(chart).show
+  end
+
+##########################################
+
+  def show_file_chooser_dialog
+    dialog = Gtk::FileChooserDialog.new("Open File",
+                                       nil,
+                                       Gtk::FileChooser::ACTION_SELECT_FOLDER,
+                                       nil,
+                                       [Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL],
+                                       [Gtk::Stock::OPEN, Gtk::Dialog::RESPONSE_ACCEPT])
+    dialog_response = dialog.run
+    return dialog_response, dialog
+  end
+
+  def clean_data_view
+    @builder['dataviewport'].each do |child|
+      @builder['dataviewport'].remove(child)
+    end
+  end
+
+  def prepare_data(raw_data, parameter)
+    data = raw_data.sort_by {|d| d.send(parameter.to_s)}.reverse
+    data.map! {|d| {label: d.to_s, value: d.send(parameter.to_s)}}
+  end
+
+  private :build_general_stats_view, :build_class_stats_view,
+    :build_method_stats_view, :build_if_smell_view,
+    :build_method_smell_view, :build_text_view
+end

data/lib/reconn/visualizer.rb

@@ -0,0 +1,44 @@
+require 'gruff'
+require 'ruby-graphviz'
+
+class Visualizer
+  def self.make_pie_chart(title, data, items_number)
+    chart = Gruff::Pie.new
+    chart.title = title.to_s
+    data = Array.new(data)
+    data.first(items_number).each do |item|
+      chart.data(item[:label], item[:value])
+      data.delete(item)
+    end
+
+    chart.data("other", data.map {|itm| itm[:value]}.inject(:+))
+
+    chart.to_blob
+  end
+
+  def self.make_bar_chart(title, data)
+    chart = Gruff::Bar.new
+    chart.minimum_value = 0
+    chart.maximum_value = data.first[:value]
+    chart.title = title.to_s
+    data.each do |item|
+      chart.data(item[:label], item[:value])
+    end
+
+    chart.to_blob
+  end
+
+  def self.make_dependency_diagram(classes)
+    diagram = GraphViz.new(:G, :type => :digraph)
+    nodes = classes.map { |c| diagram.add_nodes(c.name) }
+    classes.each do |klass|
+      classes.each do |other_klass|
+        if !klass.dependencies.index {|d| d == other_klass.name }.nil?
+          node, other_node = [klass, other_klass].map {|k| nodes.find {|n| n[:label].to_s.gsub('"', '') == k.name}}
+          diagram.add_edges(node, other_node)
+        end
+      end
+    end
+    diagram.output(:png => String)
+  end
+end

data/reconn.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reconn/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "reconn"
+  spec.version       = Reconn::VERSION
+  spec.authors       = ["Mateusz Czarnecki"]
+  spec.email         = ["mateusz.czarnecki92@gmail.com"]
+  spec.summary       = %q{A tool for analysis and visualization of projects written in Ruby}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "vrlib", ">= 1.0.16"
+  spec.add_dependency "gtk2", ">= 2.2.0"
+  spec.add_dependency "require_all", ">= 1.3.2"
+  spec.add_dependency "ruby_parser", ">= 3.6.3"
+  spec.add_dependency "sexp_processor", ">= 4.4.4"
+  spec.add_dependency "gruff", ">= 0.5.1"
+  spec.add_dependency "ruby-graphviz", ">= 1.2.1"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/reconn/analyzer/analyzer_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Analyzer do
+  describe '#analyze' do
+    before :all do
+      @result = Analyzer::Analyzer.new.analyze(File.dirname(__FILE__) + '/../../../lib')
+      @classes, @methods, @smells = @result
+    end
+
+    it 'returns an Array' do
+      expect( @result.respond_to?(:to_ary) ).to be true
+    end
+
+    it 'returns classes data' do
+      expect( @classes ).not_to be_empty
+      expect( @classes.map {|x| x.name } ).to include('Analyzer')
+    end
+
+    it 'returns methods data' do
+      expect( @methods ).not_to be_empty
+      expect( @methods.map {|x| x.name } ).to include('analyze')
+    end
+
+    it 'calculates lines of code in classes' do
+    end
+
+    it 'calculates lines of code in methods' do
+    end
+
+    it 'finds dependencies between classes' do
+    end
+  end
+end

data/spec/reconn/analyzer/project_elements/class_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module Analizer
+  describe Class do
+    it 'is not valid without a name' do
+      expect { Analizer::Class.new }.to raise_error
+    end
+  end
+end

data/spec/reconn/analyzer/project_elements/method_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module Analyzer
+  describe Method do
+    it 'is not valid without a name' do
+      expect { Method.new }.to raise_error
+    end
+  end
+end

data/spec/reconn/util/project_scanner_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ProjectScanner do
+  describe '::scan' do
+    it 'should scan the project directory' +
+      ' and return paths to ruby source files when the path is correct and the directory has .rb files' do
+      paths = ProjectScanner.scan(File.dirname(__FILE__) + '/../../test_projects')
+      expect(paths).not_to be_empty
+    end
+
+    it 'should raise an exception when the project directory path is invalid' do
+      expect { ProjectScanner.scan('a_directory')}.to raise_error
+    end
+
+    it 'should return empty array when no ruby files were found' do
+      paths = ProjectScanner.scan(File.dirname(__FILE__) + '/../../test_projects/empty_project')
+      expect(paths).to be_empty
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'reconn'