reconn 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13aa9f0063ed8270baa802db3b86f308b2aa4066
+  data.tar.gz: 1b7df1c4764ce1a90b64aab61036819d6e6d67c3
+SHA512:
+  metadata.gz: 97c1778b30eed241da1babbd81be892ffc32dadc4dfc451864bacc26ecc9dc600c841e8c7752e6b1ba229bd707c3cb58a52ebbf3aeb92c29e419f8ef6d8d3943
+  data.tar.gz: 78d10bae27845cd07162bb3470753c575811cba9bbb3a51b559bac7a9f8911de147d17c376538118fd075ceb5c8531fdaa6292a70b6738658665629c6f1c782b

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.vr_settings.yaml
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubycode_analyzer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Reconn
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'reconn'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install reconn
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/recon/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new

data/bin/reconn

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby
+
+require 'vrlib'
+
+#make program output in real time so errors visible in VR.
+STDOUT.sync = true
+STDERR.sync = true
+
+#everything in these directories will be included
+my_path = File.expand_path(File.dirname(__FILE__))
+require_all Dir.glob(my_path + "/../lib/reconn/**/*.rb")
+
+View.new.show

data/lib/reconn.rb

@@ -0,0 +1,5 @@
+require 'reconn/version'
+require 'reconn/analyzer'
+
+module Reconn
+end

data/lib/reconn/analyzer.rb

@@ -0,0 +1,201 @@
+# @author Mateusz Czarnecki <mateusz.czarnecki92@gmail.com>
+
+require 'ruby_parser'
+require 'sexp_processor'
+require_relative 'util/project_scanner'
+require_relative 'analyzer/project_elements/class.rb'
+require_relative 'analyzer/project_elements/method.rb'
+
+module Analyzer
+  class Analyzer < MethodBasedSexpProcessor
+
+    MAX_METHOD_LENGTH = 10
+    MAX_COMPLEXITY = 6
+
+    def initialize
+      super()
+      self.auto_shift_type = false
+      @classes = []
+      @methods = []
+      @smells = []
+      @current_class = Class.new(:none)
+    end
+
+    # Analyzes all the ruby files in the given directory and its subdirectories
+    # @param dir [String] path to the directory
+    # @return [Array(Array<Class>, Array<Method>, Array<CodeSmell>)] found classes,
+    #  methods and code smells
+    def analyze(dir)
+      parser = RubyParser.new
+      paths = ProjectScanner.scan(dir)
+      paths.each do |path|
+        @current_path = path
+        ast = parser.process(File.binread(path), path)
+        process ast
+        @current_class = Class.new(:none)
+      end
+
+      merged_classes = merge_duplicate_classes
+      @classes = merged_classes unless merged_classes.nil?
+
+      @classes.each do |klass|
+        klass.lines = count_lines_in_class(klass)
+        klass.complexity = count_complexity_in_class(klass)
+      end
+      prune_dependencies
+
+      # Deletes empty classes
+      @classes.delete(Class.new(:none))
+
+      @smells = find_code_smells
+
+      return @classes, @methods, @smells
+    end
+
+    #########################################
+    # Process methods:
+
+    def process_class(exp)
+      exp.shift
+      in_klass(exp.shift) do
+        @current_class = Class.new(klass_name)
+        @classes << @current_class
+        process_until_empty exp
+      end
+
+      @current_class = Class.new(:none)
+      s()
+    end
+
+    def process_defn(exp)
+      exp.shift
+      method_name = exp.shift.to_s
+      lines = count_lines_in_method(method_name)
+      @current_method = Method.new(method_name, @current_class.name, lines)
+      exp.shift
+      process_until_empty exp
+
+      @methods << @current_method
+      @current_class.add_method(@current_method)
+      @current_method = Method.new(:none)
+      s()
+    end
+
+    def process_defs(exp)
+      exp.shift
+      process_defn(exp)
+    end
+
+    def process_colon2(exp)
+      exp.shift
+      name = exp.flatten
+      name.delete :colon2
+      name.delete :const
+      name = name.join("::")
+      @current_class.add_dependency(name)
+      exp.shift
+      process_until_empty exp
+
+      s()
+    end
+
+    def process_const(exp)
+      exp.shift
+      name = exp.shift.to_s
+      @current_class.add_dependency(name)
+      exp.shift
+      process_until_empty exp
+
+      s()
+    end
+
+    def process_if(exp)
+      exp.shift
+      process_until_empty exp
+
+      @current_method.incr_complexity unless @current_method.nil?
+      s()
+    end
+    alias process_for process_if
+    alias process_when process_if
+    alias process_until process_if
+    alias process_while process_if
+    alias process_rescue process_if
+    alias process_and process_if
+    alias process_or process_if
+
+    ########################################
+
+    #Counts lines of code in a method
+    #
+    #@param method_name [String] the name of the method
+    #@return [Integer] lines of code count
+    def count_lines_in_method(method_name)
+      method_name = method_name.gsub(/[\.\|\(\)\[\]\{\}\+\\\^\$\*\?]/) {|match| '\\' + match}
+      flag = false
+      lines = []
+      File.foreach(@current_path) do |line|
+        break if line =~ /def/ && flag
+        lines << line if flag && line.strip != '' && line.strip[0] != '#'
+        flag = true if line =~ /def #{method_name}/ || line =~ /def self.#{method_name}/
+      end
+
+      lines.size
+    end
+
+    #Counts lines of code in a class (sums LOC of methods)
+    #
+    #@param klass [Class] the class
+    #@return [Integer] lines of code count
+    def count_lines_in_class(klass)
+      lines = klass.methods.map {|method| method.lines}.inject(:+)
+      lines.nil? ? 0 : lines
+    end
+
+    def count_complexity_in_class(klass)
+      complexity = klass.methods.map {|method| method.complexity}.inject(:+)
+      complexity.nil? ? 0 : complexity
+    end
+
+    #Deletes dependencies which are not classes within analyzed project
+    def prune_dependencies
+      class_names = @classes.map {|klass| klass.name}
+      @classes.each do |klass|
+        klass.dependencies =  klass.dependencies.map do |dep|
+          dep_split = dep.split('::')
+          klass_split = klass.name.split('::')
+          klass_split.pop(dep_split.size)
+          (klass_split + dep_split).join('::')
+        end
+        klass.dependencies = klass.dependencies.uniq.keep_if {|dep| dep != klass.name && class_names.include?(dep)}
+      end
+    end
+
+    def merge_duplicate_classes
+      duplicates = @classes.group_by {|c| c.name}.select {|k, v| v.size > 1}.values
+      if !duplicates.empty?
+        merged_dups = []
+        duplicates.each do |dup|
+          merged_dups << dup.inject(:+)
+        end
+        @classes.uniq {|c| c.name}.each do |klass|
+          klass = merged_dups.find {|d| d == klass} if merged_dups.include?(klass)
+        end
+      end
+    end
+
+    def find_code_smells
+      code_smells = []
+      @methods.each do |method|
+        if method.lines > MAX_METHOD_LENGTH
+          code_smells << CodeSmell.new(:too_big_method, method.class_name, method.name)
+        end
+        if method.complexity > MAX_COMPLEXITY
+          code_smells << CodeSmell.new(:too_complex_method, method.class_name, method.name)
+        end
+      end
+      code_smells
+    end
+
+  end
+end

data/lib/reconn/analyzer/code_smell.rb

@@ -0,0 +1,16 @@
+module Analyzer
+  class CodeSmell
+    attr_reader :type, :class_name, :method_name
+
+    def initialize(type, class_name = :none, method_name)
+      @type = type
+      @class_name = class_name
+      @method_name = method_name
+    end
+
+    def to_s
+      "Smell: #{@type.to_s} in Class: #{@class_name.to_s} "\
+      "Method: #{@method_name.to_s}"
+    end
+  end
+end

data/lib/reconn/analyzer/project_elements/class.rb

@@ -0,0 +1,48 @@
+module Analyzer
+  # Represents a class in the project
+  class Class
+    attr_reader :name, :methods
+    attr_accessor :lines, :complexity, :dependencies
+
+    include Comparable
+
+    def ==(other)
+      name == other.name
+    end
+
+    def initialize(name)
+      @name = name
+      @dependencies = []
+      @methods = []
+      @lines = 0
+      @complexity = 0
+    end
+
+    def add_dependency(class_name)
+      @dependencies << class_name.to_s
+    end
+
+    def add_method(method_name)
+      @methods << method_name
+    end
+
+    def methods_number
+      methods.size
+    end
+
+    def +(other)
+      other.methods.each do |method|
+        if !@methods.index(method)
+          @methods << method
+        end
+      end
+      @dependencies += other.dependencies
+      self
+    end
+
+    def to_s
+      name.to_s
+    end
+
+  end
+end

data/lib/reconn/analyzer/project_elements/method.rb

@@ -0,0 +1,28 @@
+module Analyzer
+  # Represents a method in the project
+  class Method
+    attr_reader :name, :class_name, :lines, :complexity
+
+    include Comparable
+
+    def ==(other)
+      name == other.name && class_name == other.class_name
+    end
+
+    def initialize(name, class_name = :none, lines = 0)
+      @name = name
+      @class_name = class_name
+      @lines = lines
+      @complexity = 1
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def incr_complexity
+      @complexity += 1
+    end
+
+  end
+end

data/lib/reconn/util/project_scanner.rb

@@ -0,0 +1,28 @@
+require 'find'
+
+class ProjectScanner
+  # Scans the given directory and all its subdirectories for ruby files
+  #
+  # @param proj_path [String] path to the project directory
+  # @return [Array<String>] paths to the ruby files
+  # @raise [InvalidPathException] if it can't open the directory
+  def self.scan(proj_path)
+    paths = []
+    begin
+      Find.find(proj_path) do |path|
+        if FileTest.directory?(path)
+          if File.basename(path)[0] == '.'
+            Find.prune
+          end
+        end
+        if File.extname(path) == '.rb'
+          paths << path
+        end
+      end
+    rescue
+      raise InvalidPathException, "Can't open the directory"
+    end
+
+    paths
+  end
+end