kwala 0.9.0

data/lib/kwala/build_action.rb

@@ -0,0 +1,88 @@
+class BuildAction
+  extend InheritanceTracker
+
+  def build_action(context)
+    raise "Must be implemented by subclass."
+  end
+
+  def summary_display(context)
+    raise "Must be implemented by subclass."
+  end
+
+  def detailed_display(context)
+    [nil, nil]
+  end
+
+  # a number from 1 - 10 that represents some type of rating that will help
+  # determine if the koala's expression.
+  # For now if nil, then not scorable.  This might be better as an additional method
+  # called scoreable?
+  # Default is unscoreable
+  def score
+    nil
+  end
+
+  def self.command_line_action_name
+    self.name.gsub(/BuildAction|Action/, '').kwala_underscore
+  end
+
+  def self.summary_template_file
+    "#{TEMPLATE_DIR}/#{command_line_action_name}_summary.html"
+  end
+
+  def self.detailed_template_file
+    "#{TEMPLATE_DIR}/#{command_line_action_name}_detailed.html"
+  end
+
+  def BuildAction.create_action_from_command_line_name(name)
+    imp = BuildAction.get_implementors.find do |imp|
+      imp.command_line_action_name == name
+    end
+
+    if imp
+      imp.new
+    else
+      nil
+    end
+  end
+
+  def BuildAction.command_line_action_names
+    BuildAction.get_implementors.map do |imp|
+      imp.command_line_action_name
+    end.sort
+  end
+
+
+  protected
+
+  def time_out_readlines(io, timeout_period = 300)
+    res = nil
+    begin
+      timeout(timeout_period) do
+        res = io.readlines
+      end
+    rescue TimeoutError => err
+      res = ["IO readlines timed out."]
+    end
+    res
+  end
+
+  def summary_expand(template, context)
+    res = ProjectBuilderUtils.expand_template(template, context.amrita_data)
+    Amrita::SanitizedString.new(res)
+  end
+
+  # These are bad param names, need to make them better
+  # Extremely naive function to put the errors to some scale around 10.
+  def score_scaling(errors, bounds)
+     10 - ((errors.to_f / bounds.to_f) * 10).ceil
+  end
+
+  def notify(result, data = nil)
+    Notification.notify(self.class.command_line_action_name, result, data)
+  end
+
+end
+
+class KwalaAbortBuildException < StandardError
+end

data/lib/kwala/build_context.rb

@@ -0,0 +1,49 @@
+class BuildContext
+  attr_accessor :project_directory, :ruby_files, :test_files
+  attr_accessor :amrita_data, :ri_dir_1, :ri_dir_2, :pre_requires, :require
+  attr_accessor :output_directory
+  attr_accessor :vcs_num
+  attr_reader :project_name
+
+  def initialize
+    @project_directory = @project_name = @ri_dir_1 = @ri_dir_2 =
+    @output_directory = @require = nil
+    @ruby_files = Array.new
+    @test_files = Array.new
+    @pre_requires = nil
+    self.initialize_build_data
+  end
+
+
+  def initialize_build_data()
+    @amrita_data = Hash.new
+    @amrita_data[:project_name] = self.project_name
+    @amrita_data[:build_date] = Time.now
+  end
+
+  def project_name=(project_name)
+    @project_name = project_name
+    @amrita_data[:project_name] = @project_name
+  end
+
+  def build_complete
+    @amrita_data[:complete_time] = Time.now
+    @amrita_data[:total_build_time] =  ( (@amrita_data[:complete_time] - @amrita_data[:build_date]) / 60.0 )
+  end
+
+  def vcs_info
+    if @vcs_info.nil?
+      # For now svn
+      cur = Dir.pwd
+      begin
+        Dir.chdir(self.project_directory)
+        @vcs_info = `svn log -r #{self.vcs_num} --verbose`
+      ensure
+        Dir.chdir(cur)
+      end
+    end
+
+    @vcs_info
+  end
+
+end

data/lib/kwala/command_line_runner.rb

@@ -0,0 +1,184 @@
+#! /usr/bin/ruby1.8
+
+# Copyright (c) 2006, Ubiquitous Business Technology (http://ubit.com)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#
+#    * Redistributions in binary form must reproduce the above
+#      copyright notice, this list of conditions and the following
+#      disclaimer in the documentation and/or other materials provided
+#      with the distribution.
+#
+#    * Neither the name of Ubit nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# == Author
+# Zev Blut (zb@ubit.com)
+
+puts "Starting #{Time.now}"
+
+require 'getoptlong'
+require 'kwala'
+
+def usage
+  puts "Usage: #{$0} [-d -p -a -y] -o"
+  puts "       --project_name, -p (project name): The name of the project"
+  puts "       --directory, -d (project base directory): The base directory of the project."
+  puts "                       if not set then current directory is assumed."
+  puts "       --action, -a (action name): The name of an action to execute."
+  puts "                       if no action is set then all actions are assumed."
+  puts "       --yaml, -y (yaml debug file name): The name of a file to save yaml debug information to."
+  puts "       --output_dir, -o (output directory): The directory to output results to."
+  puts "       --require,-r (file to require): A file to require for use when testing unit tests."
+  puts "       --ri_cmp_1,-1 (old ri directory): The old ri output directory to compare against."
+  puts "       --ri_cmp_2,-2 (new ri directory): The new ri output directory to compare against."
+  puts "       --list_actions, -l: Lists the action names available."
+  puts "       --notifications, -n: Activates notifications for action results."
+  puts "       --vcs_num, -v: A string with the vcs version numbers to check"
+  exit 1
+end
+
+def list_actions
+  puts "Available actions are: "
+  BuildAction.command_line_action_names.each do |name|
+    puts " #{ name }"
+  end
+end
+
+ProjectBuilderUtils.load_actions
+
+actions = Array.new
+context = BuildContext.new
+
+context.project_directory = Dir.pwd
+context.project_name = ""
+debug_results = nil
+begin
+  options = GetoptLong.new(
+    ["-p", "--project_name", GetoptLong::REQUIRED_ARGUMENT],
+    ["-d", "--dir", GetoptLong::REQUIRED_ARGUMENT],
+    ["-a", "--action", GetoptLong::REQUIRED_ARGUMENT],
+    ["-y", "--yaml", GetoptLong::REQUIRED_ARGUMENT],
+    ["-r", "--require", GetoptLong::REQUIRED_ARGUMENT],
+    ["-1", "--ri_cmp_1", GetoptLong::REQUIRED_ARGUMENT],
+    ["-2", "--ri_cmp_2", GetoptLong::REQUIRED_ARGUMENT],
+    ["-e", "--extensions", GetoptLong::REQUIRED_ARGUMENT],
+    ["-o", "--output_dir", GetoptLong::REQUIRED_ARGUMENT],
+    ["-l", "--list_actions", GetoptLong::NO_ARGUMENT],
+    ["-n", "--notifications", GetoptLong::NO_ARGUMENT],
+    ["-v", "--vcs_num", GetoptLong::REQUIRED_ARGUMENT] )
+
+  options.each do |opt, arg|
+    case opt
+    when "-p"
+      context.project_name = arg
+    when "-a"
+      actions << arg
+    when "-d"
+      context.project_directory = arg
+    when "-y"
+      debug_results = arg
+    when "-o"
+      context.output_directory = arg
+    when "-r"
+      context.pre_requires = arg
+    when "-1"
+      context.ri_dir_1 = ProjectBuilderUtils.clean_trailing_slash(arg)
+    when "-2"
+      context.ri_dir_2 = ProjectBuilderUtils.clean_trailing_slash(arg)
+    when "-e"
+      require arg
+      # required file should define get extensions
+      extensions = get_extensions
+    when "-l"
+      list_actions
+      exit 0
+    when "-n"
+      Notification.context = context
+      Notification.notifications
+      Notification.add_notification(EmailNotification.new)
+      Notification.add_notification(JabberNotification.new)
+    when "-v"
+      context.vcs_num = arg
+    else
+      STDERR.puts "Unknown argument #{opt}"
+      usage
+    end
+  end
+rescue => err
+  STDERR.puts "Error: #{err}", err.backtrace
+  usage
+end
+
+usage if context.output_directory.nil?
+
+# Set default actions if not passed
+if actions.empty?
+  actions = %w(loc_count syntax_check unit_test flagged_comments)
+end
+
+if actions.include?("code_change")
+  usage if (context.ri_dir_1 && !context.ri_dir_2) || (!context.ri_dir_1 && context.ri_dir_2)
+end
+
+# Set up necessary info before actions
+
+ruby_files, test_files = ProjectBuilderUtils.get_ruby_and_unit_test_files(context.project_directory)
+context.ruby_files = ruby_files
+context.test_files = test_files
+
+action_instances = Array.new
+actions.each do |action|
+  action_obj = BuildAction.create_action_from_command_line_name(action)
+  if action_obj
+    action_instances << action_obj
+  else
+    STDERR.puts "Unknown action : #{action}"
+    list_actions
+  end
+end
+
+# Run the build stage
+action_instances = ProjectBuilderUtils.build_actions(action_instances, context)
+
+# Run the summary stage
+summaries = ProjectBuilderUtils.build_summaries(action_instances, context)
+
+if debug_results
+  #Check the syncro of templates
+  File.open(debug_results, "w") do |f|
+    f.puts context.amrita_data.to_yaml
+  end
+end
+
+ProjectBuilderUtils.make_detailed_reports(context, action_instances)
+
+ProjectBuilderUtils.make_summary_report(context, summaries)
+
+
+# Copy the stylesheet to the output directory
+FileUtils.cp(TEMPLATE_DIR + "style.css", context.output_directory)
+FileUtils.cp_r(TEMPLATE_DIR + "mdd", context.output_directory)
+
+puts "Done #{Time.now}"

data/lib/kwala/extensions.rb

@@ -0,0 +1,36 @@
+# Provides a method that gives instances of all of the includer's subclasses.
+module InheritanceTracker
+
+  # Returns all subclasses of calling Class.
+  def get_implementors
+    imps = []
+
+    ObjectSpace.each_object(Class) do |klass|
+      if klass.ancestors.include?(self)
+        imps << klass
+      end
+    end
+
+    # remove self from the list
+    imps - [self]
+  end
+
+end
+
+class DeepCopy
+  extend Marshal
+
+  def DeepCopy.deep_copy(obj)
+    load(dump(obj))
+  end
+
+end
+
+class String
+
+  # Very Simple underscore implementation.
+  def kwala_underscore
+    self.gsub(/([A-Z])/, '_\1').downcase.gsub(/^_/, '')
+  end
+
+end

data/lib/kwala/lib/code_analyzer.rb

@@ -0,0 +1,678 @@
+#!/usr/bin/env ruby -w
+
+# Copyright (c) 2006, Ubiquitous Business Technology (http://ubit.com)
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#
+#    * Redistributions in binary form must reproduce the above
+#      copyright notice, this list of conditions and the following
+#      disclaimer in the documentation and/or other materials provided
+#      with the distribution.
+#
+#    * Neither the name of Ubit nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# == Author
+# Zev Blut (zb@ubit.com)
+
+require 'irb/ruby-lex'
+require 'pp'
+
+# Add indent to token
+module RubyToken
+  class Token
+    attr_accessor :indent
+  end
+end
+
+class FileAnalyzer
+  include RubyToken
+
+  attr_reader :file , :requires , :classes , :modules , :constants ,
+  :methods , :g_vars , :i_vars , :c_vars ,
+  :symbols , :blocks , :yields , :raises , :rescues , :cases , :aliases ,
+  :undefs , :ensures , :evals , :big_begins , :big_ends , :exits , :defines ,
+  :retries , :redoes , :nexts , :breaks , :ensures , :assignments ,
+  :is_a_kind_ofs , :method_missing , :static_methods
+
+  def initialize(file)
+    @file = file
+    @requires = []
+    @classes = []
+    @modules = []
+    @constants = []
+    @methods = []
+    @g_vars = []
+    @i_vars = []
+    @c_vars = []
+    @symbols = []
+    @blocks = 0
+    @yields = 0
+    @raises = 0
+    @rescues = 0
+    @cases = 0
+    @aliases = []
+    @undefs = []
+    @ensures = 0
+    @evals = 0
+    @big_begins = 0
+    @big_ends = 0
+    @exits = 0
+    @defines = 0
+    @retries = 0
+    @redoes = 0
+    @nexts = 0
+    @breaks = 0
+    @ensures = 0
+    @assignments = 0
+    @is_a_kind_ofs = 0
+    @method_missing = 0
+    @static_methods = []
+    @tl_ref = Hash.new
+  end
+
+  def analyze
+    #puts "Lexing File: #{ @file }"
+
+    lexer = RubyLex.new
+    lexer.exception_on_syntax_error = false
+    lexer.set_input(File.new(@file,"r"))
+
+    tokens = Array.new
+    while (tok = lexer.token)
+      tok.indent = lexer.indent
+      tokens<< tok
+      @tl_ref[tok.object_id] = lexer.line_no
+    end
+
+    i = 0
+    while i < tokens.size
+      ni = check_token(tokens[i], tokens[i..-1])
+      i += ni
+    end
+
+
+#    types, rem = BaseType.create_types_from_tokens(tokens)
+
+
+#    puts "TYPES ----------------"
+#    pp types
+#    exit 1
+
+    self
+  rescue RubyLex::SyntaxError => synerr
+    $stderr.puts synerr
+  ensure
+    self
+  end
+
+  def summarize
+    puts "-- Summary for #{ @file } --",""
+    puts "Requires".ljust(15) + ": " + @requires.size.to_s
+    puts "Modules".ljust(15) + ": " + @modules.size.to_s
+    puts "Classes".ljust(15) + ": " + @classes.size.to_s
+    puts "Constants".ljust(15) + ": " + @constants.size.to_s
+    puts "Methods".ljust(15) + ": " + @methods.size.to_s
+    puts "Static Methods".ljust(15) + ": " + @static_methods.size.to_s
+    puts "G Vars".ljust(15) + ": " + @g_vars.size.to_s
+    puts "C Vars".ljust(15) + ": " + @c_vars.size.to_s
+    puts "I Vars".ljust(15) + ": " + @i_vars.size.to_s
+    puts "Symbols".ljust(15) + ": " + @symbols.size.to_s
+    puts "Blocks".ljust(15) + ": " + @blocks.to_s
+    puts "Yields".ljust(15) + ": " + @yields.to_s
+    puts "Raises".ljust(15) + ": " + @raises.to_s
+    puts "Rescues".ljust(15) + ": " + @rescues.to_s
+    puts "Retries".ljust(15) + ": " + @retries.to_s
+    puts "Redoes".ljust(15) + ": " + @redoes.to_s
+    puts "Ensures".ljust(15) + ": " + @ensures.to_s
+    puts "Undefs".ljust(15) + ": " + @undefs.size.to_s
+    puts "Evals".ljust(15) + ": " + @evals.to_s
+    puts "Aliases".ljust(15) + ": " + @aliases.size.to_s
+    puts "BEGINs".ljust(15) + ": " + @big_begins.to_s
+    puts "ENDs".ljust(15) + ": " + @big_ends.to_s
+    puts "Exits".ljust(15) + ": " + @exits.to_s
+    puts "Defined?".ljust(15) + ": " + @defines.to_s
+    puts "Is_a? ".ljust(15) + ": " + @is_a_kind_ofs.to_s
+    puts "M missing".ljust(15) + ": " + @method_missing.to_s
+    puts "Nexts".ljust(15) + ": " + @nexts.to_s
+    puts "Breaks".ljust(15) + ": " + @breaks.to_s
+    puts "Cases".ljust(15) + ": " + @cases.to_s
+    puts "Assignments".ljust(15) + ": " + @assignments.to_s
+    puts "","",""
+
+    if @constants.size > 0
+      puts "","",""
+      puts "Constants ->", @constants.sort.uniq
+    end
+
+    if @static_methods.size > 0
+      puts "","",""
+      puts "Static methods ->", @static_methods.sort.uniq
+    end
+
+
+    puts "","----------------------------"
+  end
+
+  def check_token(tok, stack)
+    i = 1
+    case tok
+    when TkCLASS
+      name, i = find_identifier_name(stack)
+      @classes<< name
+    when TkMODULE
+      name, i = find_identifier_name(stack)
+      @modules<< name
+    when TkCONSTANT
+      #@contants<< tok.name
+      i = find_static_method_call(tok, stack)
+    when TkDEF
+      name, i = find_identifier_name(stack)
+      @methods<< name
+    when TkIDENTIFIER, TkFID
+      #@
+      case tok.name
+      when "require"
+        @requires<< nil
+      when "raise"
+        @raises += 1
+      when "eval", "instance_eval", "class_eval", "module_eval"
+        @evals += 1
+      when "is_a?", "kind_of?"
+        @is_a_kind_ofs += 1
+      when "method_missing"
+        @method_missing += 1
+      when /^exit!?$/
+        @exits += 1
+      end
+
+    when TkSYMBEG
+      name, i = find_identifier_name(stack)
+      @symbols<< name
+    when TkCVAR
+      @c_vars<< tok.name
+    when TkIVAR
+      @i_vars<< tok.name
+    when TkGVAR
+      @g_vars << tok.name
+    when TkDO,TkfLBRACE
+      # do
+      @blocks += 1
+    when TkYIELD
+      @yields += 1
+    when TkEND
+    when TkRESCUE
+      @rescues += 1
+    when TklBEGIN
+      @big_begins += 1
+    when TklEND
+      @big_ends += 1
+    when TkDEFINED
+      @defines += 1
+    when TkRETRY
+      @retries += 1
+    when TkREDO
+      @redoes += 1
+    when TkNEXT
+      @nexts += 1
+    when TkBREAK
+      @breaks += 1
+    when TkENSURE
+      @ensures += 1
+    when TkUNDEF
+      @undefs << nil
+    when TkCASE
+      @cases += 1
+    when TkALIAS
+      name, i = find_identifier_name(stack)
+      @aliases << name
+    when TkASSIGN, TkOPASGN
+      @assignments += 1
+    else
+
+    end
+    i
+  end
+
+  def find_identifier_name(stream, check_types = [TkIDENTIFIER, TkFID, TkCONSTANT])
+    i = 1
+    name = ""
+    found = false
+
+    while !found && stream[i]
+      tok = stream[i]
+      if check_types.include?(tok.class)
+        found = true
+        name = tok.name
+      else
+        i += 1
+      end
+    end
+
+    [name, i]
+  end
+
+  def find_static_method_call(tok, stream)
+    sname = tok.name.dup
+    searching = true
+    i = 1
+    while searching
+      val = stream[i]
+      case val
+      when TkDOT
+        sname<< "."
+      when TkCOLON2
+        sname<< "::"
+      when TkCONSTANT, TkIDENTIFIER, TkFID
+        sname << val.name
+      when TkNL, TkSPACE
+        searching = false
+      when TkLPAREN
+        sname<< "()"
+        searching = false
+      when TkfLBRACK
+        sname<< "[]"
+        searching = false
+      when TkfLBRACE
+        searching = false
+      when TkRPAREN, TkRBRACK, TkRBRACE, TkDOT2, TkDOT3, TkBITOR, TkBITAND,
+        TkCOMMA, TkSEMICOLON, TkPLUS, TkMINUS, TkMULT, TkDIV
+        # close of a method call
+        searching = false
+      when TkASSIGN, TkMOD
+        # could be class = ? most likely a constant
+        searching = false
+      when TkDSTRING, TkSTRING
+        # ignore the constant as it is wrapped in a string
+        searching = false
+      else
+        puts "NEW CASE #{ val.class } for #{self.file}"
+        puts "Line: #{ @tl_ref[val.object_id] }"
+        searching = false
+      end
+      i += 1
+    end
+    if tok.name != sname
+      # Make sure we don't get things like Array[] or Array()
+      if /:/ =~ sname && /^[A-Z]/ =~ sname.split(".").last.split(":").last
+        @constants << sname
+      else
+        @static_methods<< sname
+      end
+    else
+      @constants << sname
+      #puts "JUST A CONST :#{ sname } ----"
+      #puts "Line: #{ @tl_ref[tok.object_id] }"
+    end
+    i
+  end
+
+  def group_methods(tokens)
+#    meth_groups = []
+#
+#    cur_group_toks = []
+#    indent = 0
+#    indef = false
+#
+#    tokens.each do |tok|
+#      cur_group_toks<< tok
+#
+#      if tok.class == TkDEF
+#        indent = tok.indent
+#        indef = true
+#        cur_group_toks = [ tok ]
+#      elsif tok.class == TkEND
+#        if indef && (tok.indent == (indent - 1))
+#          indef = false
+#          indent = tok.indent
+#
+#          meth_groups<< cur_group_toks
+#          cur_group_toks = []
+#        end
+#      end
+#    end
+#
+#    puts "Meth group #{ meth_groups.size }"
+#    pp meth_groups
+#    exit
+#
+    groups, idx = group_tokens(tokens, [TkDEF])
+    puts "Meth groups cnt #{ groups.size }"
+    pp groups
+    exit
+  end
+
+
+
+end
+
+
+
+
+class FileAnalyzerGroup
+  def initialize(files)
+    @fa_files = []
+    files.each do |file|
+      @fa_files<< FileAnalyzer.new(file).analyze
+    end
+  end
+
+  def summarize
+    fst = @fa_files.first
+    vals = fst.instance_variables.map { |iv| iv[1..-1] }
+    # remove the instance variables we set that are not related to data tracking.
+    vals = vals - ["file", "tl_ref"]
+    t_v = vals.map do |v|
+      res = fst.send(v)
+
+      if res.is_a?(Array)
+        p = Proc.new { |v| v.size }
+      else
+        p = Proc.new { |v| v.to_i }
+      end
+      [v, p]
+    end
+
+    res = Hash.new { |h,k| h[k] = [] }
+    @fa_files.each do |f|
+      t_v.each do |method, calc|
+        res[method]<< calc.call( f.send(method) )
+      end
+    end
+
+
+    base_sum = Hash.new(0)
+
+    res.sort.each do |key, val|
+      r = val.inject(0) { |t, v| t + v }
+      base_sum[key] = r
+    end
+
+    print_summary_header(base_sum)
+
+    extra_summary( [ ["static_methods", "static methods"],
+                     ["g_vars", "global variables"],
+                     ["c_vars", "class variables"],
+                     ["i_vars", "instance variables"],
+                     ["constants", "constants"],
+                     ["methods", "methods"],
+                     ["classes", "classes"],
+                     ["modules", "modules"],
+                     ["symbols", "symbols"],
+                     ["aliases", "aliases"],
+                     ["undefs", "undefs"]
+                   ] )
+
+  end
+
+  def print_summary_header(summary)
+    puts "Summary"
+    summary.sort.each do |key, res|
+      puts "#{ key.ljust(15) } : #{res}"
+    end
+  end
+
+  def extra_summary(methods)
+    ttl_files = @fa_files.size
+
+    methods.each do |mcall, mname|
+      cnt = @fa_files.inject(0) { |cnt, f|  cnt += (f.send(mcall).size > 0 ? 1 : 0) }
+      if cnt == 0
+        next
+      end
+      msg = "#{ cnt } out of #{ ttl_files }" +
+        " (#{sprintf("%.2f",(cnt.to_f / ttl_files) * 100)} %) use #{ mname}"
+
+
+      uniqs = Hash.new { |h,k| h[k] = [] }
+      @fa_files.each do |f|
+        f.send(mcall).uniq.each do |sm|
+          uniqs[sm] << f.file
+        end
+      end
+
+      print_extra_summary(mname, msg, uniqs)
+    end
+  end
+
+  def print_extra_summary(name, msg, uniqs)
+    puts "" , "---" + msg + "---"
+    puts "#{name} used by files:", ""
+    uniqs.sort.each do |k, m|
+      puts k.to_s.ljust(30) + " -> ", "  " + m.join("\n  "), ""
+    end
+  end
+
+end
+
+class BaseType
+  include RubyToken
+
+  attr_accessor :name, :start_line, :end_line, :children, :tokens
+
+  def initialize(tokens = Array.new)
+    @children = Array.new
+
+    # These may be computed by tokens?
+    @start_line = 0
+    @end_line = 0
+    @tokens = tokens
+    @rem_tokens = []
+
+    create_child_groupings
+    analyse_self
+  end
+
+  def sub_types
+    @children.each { |c| yield c }
+  end
+
+
+  def self.create_types_from_tokens(tokens)
+    groups, idx = group_tokens(tokens, [TkCLASS, TkMODULE, TkDEF])
+
+
+    remainder_tokens = []
+    types = []
+
+    groups.each do |sub_tokens|
+
+        case sub_tokens.first
+        when TkCLASS
+          types<< ClassType.new(sub_tokens)
+        when TkMODULE
+          types<< ModuleType.new(sub_tokens)
+        when TkDEF
+          types<< DefType.new(sub_tokens)
+        else
+          remainder_tokens<< sub_tokens
+        end
+
+    end
+
+    [types, remainder_tokens]
+  end
+
+  private
+  def self.group_tokens(tokens, trigger, indent_target = nil, idx = 0)
+    groups = []
+
+    while idx < tokens.size
+      tok = tokens[idx]
+      idx += 1
+
+      if trigger.include?(tok.class)
+        indent = tok.indent
+
+        if indent_target.nil?
+          indent_target = indent - 1
+        end
+
+
+        sub_group, idx = collect_into_group(tokens, indent - 1, idx)
+
+        groups << [tok] + sub_group
+      end
+
+    end
+
+    [groups, idx]
+  end
+
+
+  def self.collect_into_group(tokens, indent_target, idx)
+    group = []
+
+    while idx < tokens.size
+      tok = tokens[idx]
+      idx += 1
+
+      group << tok
+      if tok.class == TkEND
+        if tok.indent == indent_target
+          return [group, idx]
+        elsif tok.indent < indent_target
+          puts "ERROR INDENT lower than TARGET"
+          return [group, idx]
+        else
+#          puts "NO CARE"
+        end
+      end
+    end
+
+    puts "ERROR FELL out while looking for END!"
+    return [group, idx]
+  end
+
+
+  def create_child_groupings
+    # ignore first so that we do not get stuck on self and last end
+    @children, rem = BaseType.create_types_from_tokens(@tokens[1..-2])
+    @rem_tokens = rem
+  end
+
+  def analyse_self
+  end
+
+end
+
+
+class ClassType < BaseType
+  attr_accessor :super_class, :includes
+
+  def analyse_self
+
+
+    @name = find_c_m_name
+    @super_class = find_super_class
+    @includes = find_includes
+  end
+
+  def find_c_m_name
+    ""
+  end
+
+  def find_super_class
+    nil
+  end
+
+  def find_includes
+    []
+  end
+end
+
+class ModuleType < BaseType
+  attr_accessor :includes
+end
+
+class DefType < BaseType
+  attr_accessor :arguments, :raises
+
+  def analyse_self
+    find_name
+    find_arguments
+    find_raises
+  end
+
+  def find_name
+  end
+
+  def find_arguments
+  end
+
+  def find_raises
+  end
+
+end
+
+if __FILE__ == $0
+  FileAnalyzerGroup.new(ARGV).summarize
+end
+
+__END__
+
+# LOOK for initialize calls with calling super
+#
+# More things to look for
+# Misspelled local/variables
+# No method comments
+#  Unused globals and locals (module or variable)
+# Unused function/method arguments (can ignore self)
+
+#LOOK for EMPTY RESCUE blocks.
+# I.e. a rescue that just catches the exception and does nothing.
+
+# Count # of parameters per method (over 7 warn!)
+# check for similar sequence of parameters in methods
+# Warn if inconsistent?
+# i.e. foo(a, b, c)  and moo(c, a , b)
+
+# Unused method parameters! unless it is a overriding subclass?
+
+# Have view to show all those who subclass/include/extend a class or module (Fan in)
+# Also view for normal fan out?
+
+# Check block parameters!
+
+# Variable bad things (smalltalk best practice p.103)
+# long extent (how long its value lasts )
+# wide scope (how long it can be accessed)
+# large type (How many messages it can respond to)
+
+
+
+# Method call
+Line: 63 17 Token #<RubyToken::TkIDENTIFIER:0xb7d33790>: interface
+Line: 63 18 Token #<RubyToken::TkDOT:0xb7d335d8>
+Line: 63 31 Token #<RubyToken::TkIDENTIFIER:0xb7d33024>: billing_steps
+
+Line: 64 13 Token #<RubyToken::TkFID:0xb7d30504>: nil?
+
+Line: 68 2513 Token #<RubyToken::TkNIL:0xb7d27c24>: nil
+
+
+Line: 78 12 Token #<RubyToken::TkCONSTANT:0xb7d1b7bc>: Registry
+Line: 78 13 Token #<RubyToken::TkDOT:0xb7d1b5dc>
+Line: 78 26 Token #<RubyToken::TkIDENTIFIER:0xb7d1b104>: each_behavior
+