leh-metric_fu 0.9.2

data/lib/metric_fu/flog.rb

@@ -0,0 +1,129 @@
+module MetricFu
+  
+  def self.generate_flog_report
+    Flog::Generator.generate_report
+    system("open #{Flog::Generator.metric_dir}/index.html") if open_in_browser?  
+  end
+  
+  module Flog
+    class Generator < Base::Generator
+      def generate_report
+        @base_dir = self.class.metric_dir
+        pages = []
+        flog_results.each do |filename|
+          page = Base.parse(open(filename, "r") { |f| f.read })
+          if page
+            page.filename = filename
+            pages << page
+          end
+        end
+        generate_pages(pages)
+      end
+
+      def generate_pages(pages)
+        pages.each do |page|
+          unless MetricFu::MD5Tracker.file_already_counted?(page.filename)
+            generate_page(page)
+          end
+        end      
+        save_html(ERB.new(File.read(template_file)).result(binding))
+      end
+
+      def generate_page(page)
+        save_html(page.to_html, page.path)
+      end
+
+      def flog_results
+        Dir.glob("#{@base_dir}/**/*.txt")
+      end
+      
+      def self.template_name
+        "flog"
+      end
+    end
+
+    SCORE_FORMAT = "%0.2f"
+
+    class Base
+      METHOD_LINE_REGEX = /([A-Za-z]+#.*):\s\((\d+\.\d+)\)/
+      OPERATOR_LINE_REGEX = /\s+(\d+\.\d+):\s(.*)$/
+
+      class << self
+
+        def parse(text)
+          score = text[/\w+ = (\d+\.\d+)/, 1]
+          return nil unless score
+          page = Page.new(score)
+
+          text.each_line do |method_line|
+           if match = method_line.match(METHOD_LINE_REGEX)
+              page.scanned_methods << ScannedMethod.new(match[1], match[2])
+            end
+            
+            if match = method_line.match(OPERATOR_LINE_REGEX)
+              return if page.scanned_methods.empty?
+              page.scanned_methods.last.operators << Operator.new(match[1], match[2])
+            end
+          end
+          page
+        end
+        
+      end
+    end 
+  
+    class Page < MetricFu::Base::Generator
+      attr_accessor :filename, :score, :scanned_methods
+
+      def initialize(score, scanned_methods = [])
+        @score = score.to_f
+        @scanned_methods = scanned_methods
+      end
+
+      def path
+        @path ||= File.basename(filename, ".txt") + '.html'
+      end
+
+      def to_html
+        ERB.new(File.read(template_file)).result(binding)
+      end
+
+      def average_score
+        return 0 if scanned_methods.length == 0
+        sum = 0
+        scanned_methods.each do |m|
+          sum += m.score
+        end
+        sum / scanned_methods.length
+      end
+
+      def highest_score
+        scanned_methods.inject(0) do |highest, m|
+          m.score > highest ? m.score : highest
+        end
+      end
+
+      def template_name
+        'flog_page'
+      end
+    end  
+  
+    class Operator
+      attr_accessor :score, :operator
+
+      def initialize(score, operator)
+        @score = score.to_f
+        @operator = operator
+      end
+    end  
+  
+    class ScannedMethod
+      attr_accessor :name, :score, :operators
+
+      def initialize(name, score, operators = [])
+        @name = name
+        @score = score.to_f
+        @operators = operators
+      end
+    end  
+  end
+end

data/lib/metric_fu/md5_tracker.rb

@@ -0,0 +1,52 @@
+require 'digest/md5'
+require 'fileutils'
+
+module MetricFu
+  class MD5Tracker
+
+    @@unchanged_md5s = []
+
+    class << self
+      def md5_dir(path_to_file, base_dir)
+        File.join(base_dir,
+                  path_to_file.split('/')[0..-2].join('/'))
+      end
+
+      def md5_file(path_to_file, base_dir)
+        File.join(md5_dir(path_to_file, base_dir),
+                  path_to_file.split('/').last.sub(/\.[a-z]+/, '.md5'))
+      end
+
+      def track(path_to_file, base_dir)
+        md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        FileUtils.mkdir_p(md5_dir(path_to_file, base_dir), :verbose => false)
+        f = File.new(md5_file(path_to_file, base_dir), "w")
+        f.puts(md5)
+        f.close
+        md5
+      end
+
+      def file_changed?(path_to_file, base_dir)
+        orig_md5_file = md5_file(path_to_file, base_dir)
+        return !!track(path_to_file, base_dir) unless File.exist?(orig_md5_file)
+
+        current_md5 = ""
+        file = File.open(orig_md5_file, 'r')
+        file.each_line { |line| current_md5 << line }
+        file.close
+        current_md5.chomp!
+
+        new_md5 = Digest::MD5.hexdigest(File.read(path_to_file))
+        new_md5.chomp!
+
+        @@unchanged_md5s << path_to_file if new_md5 == current_md5
+
+        return new_md5 != current_md5
+      end
+
+      def file_already_counted?(path_to_file)
+        return @@unchanged_md5s.include?(path_to_file)
+      end
+    end
+  end
+end

data/lib/metric_fu/reek.rb

@@ -0,0 +1,17 @@
+module MetricFu
+  
+  def self.generate_reek_report
+    Reek.generate_report
+    system("open #{Reek.metric_dir}/index.html") if open_in_browser?    
+  end
+    
+  class Reek < Base::Generator
+
+    def analyze
+      files_to_reek = MetricFu.reek[:dirs_to_reek].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      output = `reek #{files_to_reek.join(" ")}`
+      @matches = output.chomp.split("\n\n").map{|m| m.split("\n") }
+    end
+
+  end
+end

data/lib/metric_fu/roodi.rb

@@ -0,0 +1,17 @@
+module MetricFu
+  
+  def self.generate_roodi_report
+    MetricFu::Roodi.generate_report
+    system("open #{Roodi.metric_dir}/index.html") if open_in_browser?    
+  end
+    
+  class Roodi < Base::Generator
+
+    def analyze
+      files_to_analyze = MetricFu.roodi[:dirs_to_roodi].map{|dir| Dir[File.join(dir, "**/*.rb")] }
+      output = `roodi #{files_to_analyze.join(" ")}`
+      @matches = output.chomp.split("\n").map{|m| m.split(" - ") }
+    end
+
+  end
+end