edouard-metric_fu 1.0.2 → 1.0.3

data/lib/generators/reek.rb

@@ -1,37 +0,0 @@
-module MetricFu
-  
-  class Reek < Generator
-    REEK_REGEX = /^(\S+) (.*) \((.*)\)$/
-
-    def self.verify_dependencies!
-      `reek --help`
-      raise 'sudo gem install reek # if you want the reek tasks' unless $?.success?
-    end
-
-    def emit
-      files_to_reek = MetricFu.reek[:dirs_to_reek].map{|dir| Dir[File.join(dir, "**/*.rb")] }
-      @output = `reek #{files_to_reek.join(" ")}`
-    end
-
-    def analyze
-      @matches = @output.chomp.split("\n\n").map{|m| m.split("\n") }
-      @matches = @matches.map do |match|
-        file_path = match.shift.split('--').first
-        file_path = file_path.gsub('"', ' ').strip
-        code_smells = match.map do |smell|
-          match_object = smell.match(REEK_REGEX)
-          next unless match_object
-          {:method => match_object[1].strip,
-           :message => match_object[2].strip,
-           :type => match_object[3].strip}
-        end.compact
-        {:file_path => file_path, :code_smells => code_smells}
-      end
-    end
-
-    def to_h
-      {:reek => {:matches => @matches}}
-    end
-
-  end
-end

data/lib/generators/roodi.rb

@@ -1,31 +0,0 @@
-module MetricFu
-  class Roodi < Generator
-
-    def self.verify_dependencies!
-      `roodi --help`
-      raise 'sudo gem install roodi # if you want the roodi tasks' unless $?.success?
-    end
-
-    
-    def emit
-      files_to_analyze = MetricFu.roodi[:dirs_to_roodi].map{|dir| Dir[File.join(dir, "**/*.rb")] }
-      @output = `roodi #{files_to_analyze.join(" ")}`
-    end
-
-    def analyze
-      @matches = @output.chomp.split("\n").map{|m| m.split(" - ") }
-      total = @matches.pop
-      @matches.reject! {|array| array.empty? }
-      @matches.map! do |match|
-        file, line = match[0].split(':')
-        problem = match[1]
-        {:file => file, :line => line, :problem => problem}
-      end
-      @roodi_results = {:total => total, :problems => @matches}
-    end
-
-    def to_h
-      {:roodi => @roodi_results}
-    end
-  end
-end

data/lib/generators/saikuro.rb

@@ -1,209 +0,0 @@
-module MetricFu
- 
-  class Saikuro < Generator
-
-    def emit
-      relative_path = [File.dirname(__FILE__), '..', '..',
-                       'vendor', 'saikuro', 'saikuro.rb']
-      saikuro = File.expand_path(File.join(relative_path))
- 
-      format_directories
- 
-      options_string = MetricFu.saikuro.inject("") do |options, option|
-        options + "--#{option.join(' ')} "
-      end
- 
-      sh %{ruby "#{saikuro}" #{options_string}} do |ok, response|
-        unless ok
-          puts "Saikuro failed with exit status: #{response.exitstatus}"
-          exit 1
-        end
-      end
-    end
-
-    def format_directories
-      dirs = MetricFu.saikuro[:input_directory].join(" | ")
-      dirs = "\"#{dirs}\""
-      MetricFu.saikuro[:input_directory] = dirs
-    end
- 
-    def analyze
-      @files = []
-      saikuro_results.each do |path|
-        if Saikuro::SFile.is_valid_text_file?(path)
-          file = Saikuro::SFile.new(path)
-          if file
-            @files << file
-          end
-        end
-      end
-      @files = @files.sort_by do |file|
-        file.elements.
-             max {|a,b| a.complexity.to_i <=> b.complexity.to_i}.
-             complexity.to_i
-      end
-      @files.reverse!
-      klasses = []
-      @files.each {|f| klasses << f.elements}
-      klasses.flatten!
-      @classes = klasses.sort_by {|k| k.complexity.to_i}
-      @classes.reverse!
-      meths = []
-      @files.each {|f|
-        f.elements.each {|el|
-          el.defs.each {|defn|
-            defn.name = "#{el.name}##{defn.name}"
-            meths << defn}
-        }
-      }
-      meths = meths.sort_by {|meth| meth.complexity.to_i}
-      @meths = meths.reverse
-    end
- 
-    def to_h
-      files = @files.map do |file|
-        my_file = file.to_h
-        my_file[:filename] = file.filename
-        my_file
-      end
-      {:saikuro => {:files => files,
-                    :classes => @classes.map {|c| c.to_h},
-                    :methods => @meths.map {|m| m.to_h}
-                   }
-      }
-    end
- 
-    def saikuro_results
-      Dir.glob("#{metric_directory}/**/*.html")
-    end
-  end
- 
-  class Saikuro::SFile
- 
-    attr_reader :elements
-
-    def initialize(path)
-      @path = path
-      @file_handle = File.open(@path, "r")
-      @elements = []
-      get_elements
-    end
- 
-    def self.is_valid_text_file?(path)
-      File.open(path, "r") do |f|
-        if f.eof? || !f.readline.match(/--/)
-          return false
-        else
-          return true
-        end
-      end
-    end
- 
-    def filename
-      File.basename(@path, '_cyclo.html')
-    end
- 
-    def to_h
-      merge_classes
-      {:classes => @elements}
-    end
- 
-    def get_elements
-      begin
-        while (line = @file_handle.readline) do
-          return [] if line.nil? || line !~ /\S/
-          element ||= nil
-          if line.match /START/
-            unless element.nil?
-              @elements << element
-              element = nil
-            end
-            line = @file_handle.readline
-            element = Saikuro::ParsingElement.new(line)
-          elsif line.match /END/
-            @elements << element unless element.nil?
-            element = nil
-          else
-            element << line
-          end
-        end
-      rescue EOFError
-        nil
-      end
-    end
- 
- 
-    def merge_classes
-      new_elements = []
-      get_class_names.each do |target_class|
-        elements = @elements.find_all {|el| el.name == target_class }
-        complexity = 0
-        lines = 0
-        defns = []
-        elements.each do |el|
-          complexity += el.complexity.to_i
-          lines += el.lines.to_i
-          defns << el.defs
-        end
- 
-        new_element = {:class_name => target_class,
-                       :complexity => complexity,
-                       :lines => lines,
-                       :methods => defns.flatten.map {|d| d.to_h}}
-        new_element[:methods] = new_element[:methods].
-                                sort_by {|x| x[:complexity] }.
-                                reverse
- 
-        new_elements << new_element
-      end
-      @elements = new_elements if new_elements
-    end
- 
-    def get_class_names
-      class_names = []
-      @elements.each do |element|
-        unless class_names.include?(element.name)
-          class_names << element.name
-        end
-      end
-      class_names
-    end
- 
-  end
- 
-  class Saikuro::ParsingElement
-    TYPE_REGEX=/Type:(.*) Name/
-    NAME_REGEX=/Name:(.*) Complexity/
-    COMPLEXITY_REGEX=/Complexity:(.*) Lines/
-    LINES_REGEX=/Lines:(.*)/
- 
-    attr_reader :complexity, :lines, :defs, :element_type
-    attr_accessor :name
- 
-    def initialize(line)
-      @line = line
-      @element_type = line.match(TYPE_REGEX)[1].strip
-      @name = line.match(NAME_REGEX)[1].strip
-      @complexity = line.match(COMPLEXITY_REGEX)[1].strip
-      @lines = line.match(LINES_REGEX)[1].strip
-      @defs = []
-    end
- 
-    def <<(line)
-      @defs << Saikuro::ParsingElement.new(line)
-    end
- 
-    def to_h
-      base = {:name => @name, :complexity => @complexity.to_i, :lines => @lines.to_i}
-      unless @defs.empty?
-        defs = @defs.map do |my_def|
-          my_def = my_def.to_h
-          my_def.delete(:defs)
-          my_def
-        end
-        base[:defs] = defs
-      end
-      return base
-    end
-  end
-end

data/lib/generators/stats.rb

@@ -1,43 +0,0 @@
-module MetricFu
-
-  class Stats < Generator
-
-    def emit
-      `rake stats > #{metric_directory + '/stats.txt'}`
-    end
-
-    def analyze
-      output = File.open(metric_directory + '/stats.txt').read
-      output = output.split("\n")
-      output = output.find_all {|line| line[0].chr != "+" }
-      output = output.find_all {|line| line[0].chr != "(" }
-      output.shift
-      totals = output.pop
-      totals = totals.split("  ").find_all {|el| ! el.empty? }
-      @stats = {}
-      @stats[:codeLOC] = totals[0].match(/\d.*/)[0].to_i
-      @stats[:testLOC] = totals[1].match(/\d.*/)[0].to_i
-      @stats[:code_to_test_ratio] = totals[2].match(/1\:(\d.*)/)[1].to_f
-      
-      @stats[:lines] = output.map do |line|
-        elements = line.split("|")
-        elements.map! {|el| el.strip }
-        elements = elements.find_all {|el| ! el.empty? }
-        info_line = {}
-        info_line[:name] = elements.shift
-        elements.map! {|el| el.to_i }
-        [:lines, :loc, :classes, :methods, 
-         :methods_per_class, :loc_per_method].each do |sym|
-          info_line[sym] = elements.shift
-        end
-        info_line
-      end
-      @stats
-    end
-
-    def to_h
-      {:stats => @stats}
-    end
-
-  end
-end

data/lib/graphs/flay_grapher.rb

@@ -1,34 +0,0 @@
-require 'gruff'
-module MetricFu
-  
-  class FlayGrapher
-    
-    attr_accessor :flay_score, :labels
-    
-    def initialize
-      self.flay_score = []
-      self.labels = {}
-    end
-    
-    def get_metrics(metrics, date)
-      self.flay_score.push(metrics[:flay][:total_score].to_i)
-      self.labels.update( { self.labels.size => date })
-    end
-    
-    def graph!
-      g = Gruff::Line.new(MetricFu.graph_size)
-      g.title = "Flay: duplication"
-      g.theme = MetricFu.graph_theme
-      g.font = MetricFu.graph_font
-      g.data('flay', self.flay_score)
-      g.labels = self.labels
-      g.title_font_size = MetricFu.graph_title_font_size
-      g.legend_box_size = MetricFu.graph_legend_box_size
-      g.legend_font_size = MetricFu.graph_legend_font_size
-      g.marker_font_size = MetricFu.graph_marker_font_size
-      g.write(File.join(MetricFu.output_directory, 'flay.png'))
-    end
-    
-  end
-  
-end

data/lib/graphs/flog_grapher.rb

@@ -1,37 +0,0 @@
-require 'gruff'
-module MetricFu
-  
-  class FlogGrapher
-    
-    attr_accessor :flog_total, :flog_average, :labels
-    
-    def initialize
-      self.flog_total = []
-      self.flog_average = []
-      self.labels = {}
-    end
-    
-    def get_metrics(metrics, date)
-      self.flog_total.push(metrics[:flog][:total])
-      self.flog_average.push(metrics[:flog][:average])
-      self.labels.update( { self.labels.size => date })
-    end
-    
-    def graph!
-      g = Gruff::Line.new(MetricFu.graph_size)
-      g.title = "Flog: code complexity"
-      g.theme = MetricFu.graph_theme
-      g.font = MetricFu.graph_font
-      g.data('flog total', self.flog_total)
-      g.data('flog average', self.flog_average)
-      g.labels = self.labels
-      g.title_font_size = MetricFu.graph_title_font_size
-      g.legend_box_size = MetricFu.graph_legend_box_size
-      g.legend_font_size = MetricFu.graph_legend_font_size
-      g.marker_font_size = MetricFu.graph_marker_font_size
-      g.write(File.join(MetricFu.output_directory, 'flog.png'))
-    end
-    
-  end
-  
-end

data/lib/graphs/rcov_grapher.rb

@@ -1,34 +0,0 @@
-require 'gruff'
-module MetricFu
-  
-  class RcovGrapher
-    
-    attr_accessor :rcov_percent, :labels
-    
-    def initialize
-      self.rcov_percent = []
-      self.labels = {}
-    end
-    
-    def get_metrics(metrics, date)
-      self.rcov_percent.push(metrics[:rcov][:global_percent_run])
-      self.labels.update( { self.labels.size => date })
-    end
-    
-    def graph!
-      g = Gruff::Line.new(MetricFu.graph_size)
-      g.title = "Rcov: code coverage"
-      g.theme = MetricFu.graph_theme
-      g.font = MetricFu.graph_font
-      g.data('rcov', self.rcov_percent)
-      g.labels = self.labels
-      g.title_font_size = MetricFu.graph_title_font_size
-      g.legend_box_size = MetricFu.graph_legend_box_size
-      g.legend_font_size = MetricFu.graph_legend_font_size
-      g.marker_font_size = MetricFu.graph_marker_font_size
-      g.write(File.join(MetricFu.output_directory, 'rcov.png'))
-    end
-    
-  end
-  
-end

data/lib/graphs/reek_grapher.rb

@@ -1,44 +0,0 @@
-require 'gruff'
-module MetricFu
-  
-  class ReekGrapher
-    
-    attr_accessor :reek_count, :labels
-    
-    def initialize
-      self.reek_count = {}
-      self.labels= {}
-    end
-    
-    def get_metrics(metrics, date)
-      counter = self.labels.size
-      self.labels.update( { counter => date })
-      
-      metrics[:reek][:matches].each do |reek_chunk|
-        reek_chunk[:code_smells].each do |code_smell|
-          # speaking of code smell...
-          self.reek_count[code_smell[:type]] = [] if self.reek_count[code_smell[:type]].nil?
-          self.reek_count[code_smell[:type]][counter].nil? ? self.reek_count[code_smell[:type]][counter] = 1 : self.reek_count[code_smell[:type]][counter] += 1
-        end
-      end
-    end
-    
-    def graph!
-      g = Gruff::Line.new(MetricFu.graph_size)
-      g.title = "Reek: code smells"
-      g.theme = MetricFu.graph_theme
-      g.font = MetricFu.graph_font
-      self.reek_count.each_pair do |type, count|
-        g.data(type, count)
-      end
-      g.labels = self.labels
-      g.title_font_size = MetricFu.graph_title_font_size
-      g.legend_box_size = MetricFu.graph_legend_box_size
-      g.legend_font_size = MetricFu.graph_legend_font_size
-      g.marker_font_size = MetricFu.graph_marker_font_size
-      g.write(File.join(MetricFu.output_directory, 'reek.png'))
-    end
-    
-  end
-  
-end