saikuro_treemap 0.1

data/.gitignore

@@ -0,0 +1,3 @@
+tmp
+reports
+*.gem

data/MIT-LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 ThoughtWorks, Inc. (http://thoughtworks.com)
+
+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.textile

@@ -0,0 +1,65 @@
+h2. Saikuro Treemap Generator
+
+This gem generates a "treemap":http://en.wikipedia.org/wiki/Treemapping
+showing the complexity of ruby code on which it is run. It uses 
+"Saikuro":http://saikuro.rubyforge.org/ under the covers to analyze ruby
+code complexity.
+
+The size of blocks in the treemap is representative of the size of the
+code element represented by that block. The color of the block indicates
+complexity of that particular code element. Green is good, red is bad, 
+blue is somewhere in between.
+
+Small evenly distributed blocks which are green in color is indicative of
+good code.
+
+h2. Usage
+
+We clearly need to make the gem install a bit easier, but for now:
+
+* checkout this repos from github
+* build the saikuro_treemap gem...
+* >rake gem 
+* install saikuro_treemap gem...
+* >sudo gem install saikuro_treemap 
+* add a rake task like below to your project, adjusting :code_dirs for your project:
+
+<pre>
+    require 'saikuro_treemap'
+  
+    namespace :metrics do
+      desc 'generate ccn treemap'
+      task :ccn_treemap do
+        SaikuroTreemap.generate_treemap :code_dirs => ['lib']
+        `open reports/saikuro_treemap.html`
+      end
+    end
+</pre> 
+  
+* run the task to see the treemap in your browser
+
+h2. License
+
+Saikuro Treemap Generator is MIT Licensed
+
+The MIT License
+
+Copyright (c) 2010 ThoughtWorks, Inc. (http://thoughtworks.com)
+
+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/Rakefile

@@ -0,0 +1,62 @@
+require 'rake'
+require 'rake/testtask'
+
+$: << 'lib'
+require 'saikuro_treemap'
+
+namespace :metrics do
+  desc 'generate ccn treemap'
+  task :ccn_treemap do
+    SaikuroTreemap.generate_treemap :code_dirs => ['lib']
+    `open reports/saikuro_treemap.html`
+  end
+end
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # Too bad.
+else
+  task "saikuro_treemap.gemspec" do
+    spec = Gem::Specification.new do |s|
+      s.name            = "saikuro_treemap"
+      s.version         = 0.1
+      s.platform        = Gem::Platform::RUBY
+      s.summary         = "Generate CCN Treemap based on saikuro analysis"
+      
+      s.description = <<-EOF
+      Generate CCN Treemap based on saikuro analysis
+    EOF
+      s.add_dependency    'json'
+      s.add_dependency    'Saikuro'
+
+      s.files           = `git ls-files`.split("\n") + %w(saikuro_treemap.gemspec)
+      s.bindir          = 'bin'
+      s.require_path    = 'lib'
+      s.has_rdoc        = false
+      s.extra_rdoc_files = ['README.textile']
+      s.test_files      = Dir['test/{test,spec}_*.rb']
+      
+      s.author          = 'ThoughtWorks Studios'
+      s.email           = 'studios@thoughtworks.com'
+      s.homepage        = 'http://github.com/ThoughtWorksStudios/saikuro_treemap'
+      s.rubyforge_project = 'saikuro_treemap'      
+    end
+
+    File.open("saikuro_treemap.gemspec", "w") { |f| f << spec.to_ruby }
+  end
+
+  task :gem => ["saikuro_treemap.gemspec"] do
+    sh "gem build saikuro_treemap.gemspec"
+  end
+end
+
+task :test do
+  Rake::TestTask.new do |t|
+     t.libs << "test"
+     t.test_files = FileList['test/*test.rb']
+     t.verbose = true
+   end
+end
+
+task :default => :test

data/lib/saikuro_treemap/ccn_node.rb

@@ -0,0 +1,76 @@
+module SaikuroTreemap
+  class CCNNode
+    attr_reader :path
+    
+    def initialize(path, complexity=0, lines=0)
+      @path = path
+      @children = []
+      @complexity = complexity
+      @lines = lines
+    end
+
+    def add_child(child)
+      @children << child
+    end
+
+    def find_node(*pathes)
+      return self if pathes.join("::") == @path
+      return self if pathes.empty?
+
+      # Eumerable#find is buggy for recursive calls!
+      @children.each do |child|
+        if r = child.find_node(pathes)
+          return r 
+        end
+      end
+      return nil
+    end
+
+    def create_nodes(*pathes)
+      pathes.each_with_index {|_, i| find_or_create_node(*pathes[0..i]) }
+    end
+    
+    def to_json(*args)
+      hash = { 'name' => compact_name, 'id' => @path, 'children' => @children }
+      data = {}
+      data['complexity'] =  @complexity if @complexity != 0
+      data['lines'] = @lines if @lines != 0
+      data['$area'] = area if area != 0
+      data['$color'] = color if area != 0
+      hash['data'] = data
+      hash.to_json(*args)
+    end
+    
+    def area
+      return @lines if leaf?
+      @children.inject(0) {|sum, child| sum + child.area }
+    end
+    
+    def color
+      return "#101010" unless leaf?
+      return "#AE0000" if @complexity >= 10
+      return "#006500" if @complexity < 5
+      return "#4545C2"
+    end
+    
+    def leaf?
+      return @children.empty?
+    end
+    
+    private
+    
+    def compact_name
+      return '' if @path !~ /\S/
+      @path.split('::').last.split('#').last
+    end
+    
+    def find_or_create_node(*pathes)
+      find_node(*pathes) || create_node(*pathes)
+    end
+    
+    def create_node(*pathes)
+      parent = find_node(*pathes[0..-2])
+      parent.add_child(CCNNode.new(pathes.join("::")))
+    end
+  end
+end

data/lib/saikuro_treemap/parser.rb

@@ -0,0 +1,162 @@
+# almost all of code in this file is from metric_fu
+# http://metric-fu.rubyforge.org/
+module SaikuroTreemap    
+  module Parser
+    def self.parse(saikuro_out_dir)
+      files = Dir[File.join(saikuro_out_dir, "/**/*.html")].collect do |path|
+        SFile.new(path) if SFile.is_valid_text_file?(path)
+      end
+
+      files.compact!
+
+      files = files.sort_by do |file|
+        file.elements.
+             max {|a,b| a.complexity.to_i <=> b.complexity.to_i}.
+             complexity.to_i
+      end.reverse
+
+      files.each do |file|
+        file.elements.each do |element|
+          element.defs.each do |defn|
+            defn.name = "#{element.name}##{defn.name}"
+          end
+        end
+      end
+
+      files.collect(&:to_h)
+    end
+    
+    class SFile
+       attr_reader :elements
+
+       def initialize(path)
+         @path = path
+         @file_handle = File.open(@path, "r")
+         @elements = []
+         get_elements
+       ensure
+         @file_handle.close if @file_handle
+       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 = ParsingElement.new(line)
+             elsif line.match /END/
+               @elements << element if element
+               element = nil
+             else
+               element << line if element
+             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 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 << 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
+  
+
+end

data/lib/saikuro_treemap.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+require 'json'
+require 'erb'
+require 'rake'
+
+require 'saikuro_treemap/parser'
+require 'saikuro_treemap/ccn_node'
+
+module SaikuroTreemap
+  
+  DEFAULT_CONFIG = {
+    :code_dirs => ['app/controllers', 'app/models', 'app/helpers' 'lib'],
+    :output_file => 'reports/saikuro_treemap.html',
+    :saikuro_args => [
+      "--warn_cyclo 5",
+      "--error_cyclo 7",
+      "--formater text",
+      "--cyclo --filter_cyclo 0"]
+  }
+  
+  def self.generate_treemap(config={})    
+    temp_dir = 'tmp/saikuro'
+    
+    config = DEFAULT_CONFIG.merge(config)
+    
+    config[:saikuro_args] << "--output_directory #{temp_dir}"
+    
+    options_string = config[:saikuro_args] + config[:code_dirs].collect { |dir|  "--input_directory '#{dir}'" }
+    
+    
+    rm_rf temp_dir
+    sh %{saikuro #{options_string.join(' ')}} do |ok, response| 
+      unless ok 
+        puts "Saikuro failed with exit status: #{response.exitstatus}" 
+        exit 1 
+      end 
+    end
+    
+    saikuro_files = Parser.parse(temp_dir)
+    
+    @ccn_node = create_ccn_root_node(saikuro_files)    
+    FileUtils.mkdir_p(File.dirname(config[:output_file]))
+
+    File.open(config[:output_file], 'w') do |f|
+      f << ERB.new(File.read(template('saikuro.html.erb'))).result(binding)
+    end
+  end
+  
+  def self.create_ccn_root_node(saikuro_files)
+    root_node = CCNNode.new('')
+    saikuro_files.each do |f|      
+      f[:classes].each do |c|
+        class_node_name = c[:class_name]
+        namespaces = class_node_name.split("::")[0..-2]
+        root_node.create_nodes(*namespaces)
+        parent = root_node.find_node(*namespaces)
+        class_node = CCNNode.new(class_node_name, c[:complexity], c[:lines])
+        parent.add_child(class_node)
+
+        c[:methods].each do |m|
+          class_node.add_child(CCNNode.new(m[:name], m[:complexity], m[:lines]))
+        end
+      end
+    end
+
+    root_node
+  end
+    
+  def self.template(file)
+    File.expand_path("../../templates/#{file}", __FILE__)
+  end
+
+end
+

data/saikuro_treemap.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{saikuro_treemap}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["ThoughtWorks Studios"]
+  s.date = %q{2010-07-16}
+  s.description = %q{      Generate CCN Treemap based on saikuro analysis
+}
+  s.email = %q{studios@thoughtworks.com}
+  s.extra_rdoc_files = ["README.textile"]
+  s.files = [".gitignore", "MIT-LICENSE.txt", "README.textile", "Rakefile", "lib/saikuro_treemap.rb", "lib/saikuro_treemap/ccn_node.rb", "lib/saikuro_treemap/parser.rb", "saikuro_treemap.gemspec", "templates/css/treemap.css", "templates/js/jit-min.js", "templates/js/jit.js", "templates/js/saikuro-render.js", "templates/saikuro.html.erb", "test/ccn_node_test.rb", "test/test_helper.rb"]
+  s.homepage = %q{http://github.com/ThoughtWorksStudios/saikuro_treemap}
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{saikuro_treemap}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Generate CCN Treemap based on saikuro analysis}
+  s.test_files = ["test/test_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<Saikuro>, [">= 0"])
+    else
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<Saikuro>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<Saikuro>, [">= 0"])
+  end
+end

data/templates/css/treemap.css

@@ -0,0 +1,33 @@
+html, body {
+    margin:0;
+    padding:0;
+    font-family: "Lucida Grande", Verdana;
+    font-size: 0.9em;
+    background-color:#F2F2F2;
+}
+
+.node {
+  color:#FFFFFF;
+  overflow:hidden;
+  cursor:pointer;
+}
+
+#infovis {
+    text-align: center;
+    position:relative;
+    width:90%;
+    height:900px;
+    margin:auto;
+    overflow:hidden;
+}
+
+.tip {
+    color: #fff;
+    width: auto;
+    background-color: black;
+    opacity:0.9;
+    filter:alpha(opacity=90);
+    font-size:10px;
+    font-family:Verdana, Geneva, Arial, Helvetica, sans-serif;
+    padding:7px;
+}