kwala 0.9.0

data/lib/kwala/lib/cycle_detector.rb

@@ -0,0 +1,793 @@
+
+
+
+
+
+
+
+#!/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 'kwala'
+
+class CycleDetector
+
+  attr_writer :print_strategy
+
+  def initialize
+    @graph = Hash.new
+    @print_strategy = STDOUTPrintStrategy.new
+    @filter = Proc.new do |files|
+      files.find_all do |f|
+        /tests\// !~ f && /extensions\// !~ f &&
+          /tools\// !~ f && /\/ms\// !~ f && /\/site\// !~f
+      end
+    end
+  end
+
+  def make_graph(dir, convert = nil)
+    files = ReqWalker.find_ruby_files(dir)
+
+    if convert
+      files = ReqWalker.convert_files_path_to(files, convert.from, convert.to)
+    end
+
+    files = @filter.call(files)
+
+    build_graph_from_edges(files)
+    reset_state
+  end
+
+  def find_cycles
+    cycles = Array.new
+    @graph.each do |req, node|
+
+      cycle = find_cycle(node, [])
+      if cycle
+        cycles<< cycle
+      end
+
+      reset_state
+    end
+    cycles
+  end
+
+  def size
+    @graph.size
+  end
+
+
+  def print_graph
+    reset_state
+    @print_strategy.print_graph(@graph)
+    reset_state
+  end
+
+  def print_cycles(cycles)
+    reset_state
+    @print_strategy.print_cycles(cycles)
+    reset_state
+  end
+
+  def print_unique_cycles(cycles)
+    reset_state
+    @print_strategy.print_cycles( unique_cycles(cycles) )
+    reset_state
+  end
+
+  ##############################################################################
+  protected
+
+  def build_graph_from_edges(edges)
+    edges.each do |f|
+      cf = ReqWalker.clean_file(f)
+      if (!@graph.key?(cf) || @graph[cf].state == Node::UNVISITED)
+        build_node(f, cf)
+      end
+    end
+  end
+
+  def build_node(file, clean_name)
+
+    if @graph.key?(clean_name)
+      node = @graph[clean_name]
+    else
+      node = Node.new( clean_name )
+      @graph[clean_name] = node
+    end
+
+    node.state = Node::INPROGRESS
+    edges = ReqWalker.get_requires(file)
+    edges = @filter.call(edges)
+    edges = edges.find_all { |f| ReqWalker.find_file(f) }
+    edges.each do |edg_file|
+      ce = ReqWalker.clean_file(edg_file)
+      if !@graph.key?(ce)
+        edge_node = Node.new(ce)
+        @graph[ce] = edge_node
+      else
+        edge_node = @graph[ce]
+      end
+
+      node.edges << edge_node
+    end
+
+    build_graph_from_edges(edges)
+    node.state = Node::DONE
+  end
+
+  def find_cycle(node, path = Array.new)
+    begin
+      path << node.name
+      node.state = Node::INPROGRESS
+
+      all_cycles = Array.new
+
+      node.edges.each do |edge|
+        npath = path.dup
+        case edge.state
+        when Node::INPROGRESS
+          npath << edge.name
+          return npath
+        when Node::DONE
+          nil
+        else
+          c = find_cycle(edge, npath)
+          if c
+            return c
+          end
+        end
+      end
+
+      node.state = Node::DONE
+    rescue SystemStackError => err
+      puts err.class
+      puts "<"
+      puts path
+      puts ">"
+      node.state = Node::DONE
+      nil
+    end
+    nil
+  end
+
+  def reset_state
+    @graph.each do |k, v|
+      v.reset
+    end
+  end
+
+  def unique_cycles(cycles)
+    uniq = Hash.new
+
+    cycles.each do |cycle|
+      uf = Hash.new
+      cycle.each_with_index do |p, i|
+        if uf.key?(p)
+          # only add new cycles
+          if !uniq.key?(p)
+            cyc = cycle[uf[p] .. -1]
+            uniq[p] = cyc
+          end
+        else
+          uf[p] = i
+        end
+      end
+    end
+
+    uniq.values
+  end
+
+  class Node
+    DONE = "DONE"
+    INPROGRESS = "INPROGRESS"
+    UNVISITED = "UNVISITED"
+
+    attr_accessor :name, :edges, :state
+
+    def initialize( name = self.object_id )
+      @name = name
+      @edges = Array.new
+      @state = UNVISITED
+    end
+
+    def reset
+      @state = UNVISITED
+    end
+  end
+
+  class STDOUTPrintStrategy
+
+    def print_graph(graph)
+      puts "Graph is #{ graph.size}"
+
+      graph.each do |k, v|
+        print_node(v)
+      end
+    end
+
+    def print_cycles(cycles)
+      if cycles.size > 0
+        puts "Directory has #{cycles.size} CYCLES !"
+        cycles.each do |path|
+          print_cycle_path(path)
+        end
+      end
+    end
+
+
+    ############################################################################
+    protected
+
+    def print_node(node)
+      if node.state == CycleDetector::Node::UNVISITED
+        node.state = CycleDetector::Node::INPROGRESS
+        puts " --- #{ node.name } --- (#{node.edges.size} edges)"
+        node.edges.each do |eg|
+          puts "     -> #{ eg.name }"
+        end
+        node.state = CycleDetector::Node::DONE
+      end
+    end
+
+    def print_cycle_path(path)
+      puts ""
+      puts "#{path.first} <-> #{ path.last}"
+      puts "  " + path.join("\n  ")
+      puts ""
+    end
+
+  end
+
+  class DOTPrintStrategy
+    def initialize
+      @visited = Hash.new(false)
+    end
+
+    def print_graph(graph)
+      print_dot_wrapper do
+        print_sub_clusers(graph.keys)
+
+        graph.sort.each do |k, v|
+          print_node(v)
+        end
+      end
+    end
+
+    def print_cycles(cycles)
+      print_dot_wrapper do
+        if cycles.size > 0
+
+          cycles.each do |path|
+            print_cycle_path(path)
+          end
+
+        end
+      end
+    end
+
+    ############################################################################
+    protected
+
+    def print_dot_wrapper(&block)
+      @visited.clear
+      puts "digraph G {"
+      puts " center=1;"
+      puts " rankdir=LR;"
+      puts " ratio=compress;"
+      puts " size=\"20,20\";"
+
+      yield
+
+      puts "}"
+      @visited.clear
+    end
+
+    def print_node(node)
+      if node.state == CycleDetector::Node::UNVISITED
+        node.state = CycleDetector::Node::INPROGRESS
+        if !@visited.key?(node.name)
+          puts " \"#{ node.name }\";"
+          @visited[node.name] = true
+        end
+        node.edges.each do |edge|
+          puts " \"#{ node.name}\" -> \"#{ edge.name }\";"
+        end
+        node.state = CycleDetector::Node::DONE
+      end
+    end
+
+    def print_cycle_path(path)
+      # Group up the adjacent items into pairs
+      path[0..-2].zip(path[1..-1]) do |head, tail|
+        vkey = "#{head},#{tail}"
+        # Only print the unvisited nodes
+        if !@visited.key?(vkey)
+          puts " \"#{ head }\" -> \"#{ tail }\";"
+          @visited[vkey] = true
+        end
+      end
+    end
+
+    def print_sub_clusers(keys)
+      clusters = make_clusters(keys)
+      print_sub_clusters_and_members(clusters)
+    end
+
+    DEFAULTCLUSTER = ""
+
+    def print_sub_clusters_and_members(clusters, idx = "0", indent = 1)
+      padding = "  " * (indent + 1)
+      opadding = "  " * indent
+
+      clusters.sort.each do |cluster_name, members|
+        next if cluster_name == DEFAULTCLUSTER
+        puts "", opadding + "subgraph cluster#{ idx } { "
+        puts padding + "label = \"#{cluster_name}\";"
+
+        subs, mems = members.partition{ |m| m.is_a?(Hash) }
+
+        print_cluster_members(mems, padding)
+
+        tidx = idx + "_a"
+        subs.each do |member|
+          puts ""
+          print_sub_clusters_and_members(member, tidx , indent + 1)
+          tidx = tidx.succ
+        end
+
+
+        puts "", opadding + "}", ""
+        idx = idx.succ
+      end
+
+      idx
+    end
+
+    def print_cluster_members(mems, padding)
+      #group into 4s
+      groupings = Array.new
+      cgroup = nil
+
+      mems.each_with_index do |m, i|
+        if ( i % 4 == 0)
+          cgroup = Array.new
+          groupings<< cgroup
+        end
+        cgroup << m
+      end
+
+      groupings.each do |vals|
+        puts padding + "{ rank = same; "
+        puts padding + " \"" + vals.join("\"; \"") + "\";"
+        vals.each { |v| @visited[v] = true }
+
+        puts padding + "}", ""
+      end
+
+    end
+
+    def make_clusters(keys)
+      groups = Hash.new { |h,k| h[k] = Array.new }
+
+      keys.sort.each do |k|
+        if k.include?("/")
+          spname = k.split("/")
+          gname = spname[0..-2].join("/")
+        else
+          gname = DEFAULTCLUSTER
+        end
+        groups[gname] << k
+      end
+
+      sub_group_clusters(groups)
+    end
+
+    def sub_group_clusters(groups)
+
+
+      groups.keys.sort.each do |key|
+        if key.include?("/")
+          spname = key.split("/")
+          gname = spname[0..-2].join("/")
+
+          if groups.key?(gname)
+            groups[gname] << { key => groups[key] }
+          end
+        end
+      end
+
+      # now condense
+      groups.keys.sort.reverse.each do |key|
+
+        (groups.keys - [key]).reverse.sort.each do |gkey|
+          subs = groups[gkey].find_all { |v| v.kind_of?(Hash) }
+          if subs
+            sk = (subs.map { |k| k.keys }).flatten
+            if sk.include?(key)
+              groups.delete(key)
+              break
+            end
+          end
+        end
+
+      end
+
+
+      groups
+    end
+
+  end
+
+
+  class GraphMLPrintStrategy
+
+    def initialize
+      @visited = Hash.new(false)
+      @edges = []
+      @nodeid = Hash.new
+      @cid = 0
+    end
+
+    def print_graph(graph)
+      print_ml_wrapper do
+        #print_sub_clusers(graph.keys)
+
+        # Reorder the nodes based upon if it has edges or not.
+        # Prefuse, fails if the first nodes do not have any links to
+        # or from it.
+        noedge, edge = graph.sort.partition { |k,v| v.edges.empty? }
+
+        (edge + noedge).each do |k, v|
+          print_node(v)
+        end
+
+        print_edges
+      end
+    end
+
+    def print_cycles(cycles)
+      print_ml_wrapper do
+        if cycles.size > 0
+
+          cycles.each do |path|
+            puts "Nothing"
+          end
+
+        end
+      end
+    end
+
+    ############################################################################
+    protected
+
+    def print_ml_wrapper(&block)
+      @visited.clear
+
+      puts "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+      puts "<graphml xmlns=\"http://graphml.graphdrawing.org/xmlns\">"
+      puts "<graph edgedefault=\"directed\">"
+      puts "<!-- data schema -->"
+      puts "<key id=\"name\" for=\"node\" attr.name=\"name\" attr.type=\"string\"/>"
+
+      yield
+
+      puts "</graph>"
+      puts "</graphml>"
+
+      @visited.clear
+      @edges = []
+      @cid = 0
+      @nodeid.clear
+    end
+
+    def print_node(node)
+      if node.state == CycleDetector::Node::UNVISITED
+        node.state = CycleDetector::Node::INPROGRESS
+        if !@visited.key?(node.name)
+          @cid += 1
+          @nodeid[node.name] = @cid
+          puts "<node id=\"#{ @cid }\">"
+          puts " <data key=\"name\">#{ node.name }</data>"
+          puts "</node>"
+          @visited[node.name] = true
+        end
+        node.edges.each do |edge|
+          @edges << [node.name, edge.name ]
+        end
+        node.state = CycleDetector::Node::DONE
+      end
+    end
+
+    def print_edges
+      @edges.each do |src, tgt|
+        sid = @nodeid[src]
+        tid = @nodeid[tgt]
+        puts "<edge source=\"#{sid}\" target=\"#{tid}\"></edge>"
+      end
+    end
+
+  end
+
+
+  class DKWonMLPrintStrategy
+
+    def initialize
+      @visited = Hash.new(false)
+      @edges = []
+      @nodeid = Hash.new
+      @cid = 0
+    end
+
+    def print_graph(graph)
+      print_ml_wrapper do
+
+        noedge, edge = graph.sort.partition { |k,v| v.edges.empty? }
+
+        (edge + noedge).each do |k, v|
+          print_node(v)
+        end
+        
+      end
+    end
+
+    def print_cycles(cycles)
+      print_ml_wrapper do
+        if cycles.size > 0
+
+          cycles.each do |path|
+            puts "Nothing"
+          end
+
+        end
+      end
+    end
+
+    ############################################################################
+    protected
+
+    def print_ml_wrapper(&block)
+      @visited.clear
+
+      puts "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+      puts "<graph edgedefault=\"directed\">"
+      puts "<!-- DK data schema -->"
+      puts "<key id=\"name\" for=\"node\" attr.name=\"name\" attr.type=\"string\"/>"
+
+      yield
+
+      puts "</graph>"
+
+      @visited.clear
+      @edges = []
+      @cid = 0
+      @nodeid.clear
+    end
+
+    def print_node(node, indent = 0)
+      if node.state == CycleDetector::Node::UNVISITED
+        node.state = CycleDetector::Node::INPROGRESS
+        if !@visited.key?(node.name)
+          head = (' ' * indent ) + "<node name=\"#{ node.name.strip }\""
+          if node.edges.empty?
+            puts head + " />"
+          else
+            puts head + " >"
+            node.edges.each do |edge|
+              print_node(edge, indent + 1)
+            end
+            puts (' ' * indent ) + "</node>"
+          end
+          @visited[node.name] = true
+        end
+        node.state = CycleDetector::Node::DONE
+      elsif node.state == CycleDetector::Node::INPROGRESS
+        puts (' ' * indent ) + "<node name=\"#{ node.name.strip }\" />"
+      end
+    end
+
+  end
+
+end
+
+
+
+
+class ReqWalker
+  URL = "/"
+  REQUIRE_REG = /^\s*require\s*\(?\s*[\(\'\"]([\w\-\/\.]+)[\"\'\)]/
+
+  def self.get_requires(file)
+    reqs = Array.new
+    path = find_file(file)
+    return reqs if path.nil?
+
+    IO.readlines(path).each_with_index do |line, idx|
+      # Add this break to ignore requires at the end...
+      break if idx > 150
+      if r = get_require(line)
+        reqs<< r
+      end
+    end
+
+    reqs
+  end
+
+  def self.get_require(line)
+    if m = REQUIRE_REG.match(line)
+      return m[1].split(" ").first.gsub("\"","").gsub("'","")
+    else
+      return nil
+    end
+  end
+
+  def self.find_file(file)
+    return nil if file =~ /\.so$/
+
+    if file !~ /\.rb$/
+      nfile = file + ".rb"
+    else
+      nfile = file
+    end
+
+    [file, nfile].uniq.each do |chk|
+      if File.exists?(chk) && !File.directory?(chk)
+        return chk
+      end
+    end
+
+    filter_path($LOAD_PATH).each do |path|
+      #$LOAD_PATH.each do |path|
+      npath = path + "/" + nfile
+      if File.exists?(npath) && !File.directory?(npath)
+        return npath
+      end
+    end
+    nil
+  end
+
+  def self.filter_path(path)
+    #path.find_all { |p| p !~ /\/ruby\/1\.8/ } #|| p !~ /\/ruby\/site_ruby\/1\.8/ }
+    #["./"]
+    []
+    path
+  end
+
+  def self.clean_file(file)
+    # Get rid of any "./a.rb" files as they will make duplicates
+    if m = /^\.\/(.*)/.match(file)
+      file = m[1]
+    end
+
+    if m = /(.*)?(\.rb|\.so)$/.match(file)
+      m[1]
+    else
+      file
+    end
+  end
+
+  def self.clean_files(files)
+    nfiles = Array.new
+    files.each do |f|
+      nfiles<< clean_file(f)
+    end
+    nfiles
+  end
+
+  def self.find_ruby_files(dir)
+    ProjectBuilderUtils.find_ruby_files(dir)
+  end
+
+  def self.convert_files_path_to(files, from = "./", to = "")
+    files.map { |f| f.sub(from, to) }
+  end
+
+end
+
+class PathConvert
+  attr_accessor :from , :to
+
+  def initialize
+    @from = "./"
+    @to = ""
+  end
+
+end
+
+if __FILE__ == $0
+  require 'getoptlong'
+
+  def usage
+    exit 1
+  end
+
+  cd = CycleDetector.new
+  print_graph = false
+  dir = "./"
+  convert = nil
+
+  begin
+    options = GetoptLong.new(
+                             ["-i","--dot", GetoptLong::NO_ARGUMENT],
+                             ["-m","--graphml", GetoptLong::NO_ARGUMENT],
+                             ["-k","--dkwonml", GetoptLong::NO_ARGUMENT],
+                             ["-g","--graph", GetoptLong::NO_ARGUMENT],
+                             ["-d","--dir", GetoptLong::REQUIRED_ARGUMENT],
+                             ["-f","--from", GetoptLong::REQUIRED_ARGUMENT],
+                             ["-t","--to", GetoptLong::REQUIRED_ARGUMENT]
+                             )
+
+    options.each do |opt,arg|
+      case opt
+      when "-i"
+        cd.print_strategy = CycleDetector::DOTPrintStrategy.new
+      when "-m"
+        cd.print_strategy = CycleDetector::GraphMLPrintStrategy.new
+      when "-k"
+        cd.print_strategy = CycleDetector::DKWonMLPrintStrategy.new
+      when "-g"
+        print_graph = true
+      when "-d"
+        dir = arg
+      when "-f"
+        convert = PathConvert.new if convert.nil?
+        convert.from = arg
+      when "-t"
+        convert = PathConvert.new if convert.nil?
+        convert.to = arg
+      else
+        STDERR.puts "Unknown command #{ opt }"
+        usage
+      end
+    end
+  rescue => err
+    STDERR.puts "Error invalid command"
+    usage
+  end
+
+  cd.make_graph(dir, convert)
+
+  if print_graph
+    cd.print_graph
+  else
+    cycles = cd.find_cycles
+    #cd.print_cycles(cycles)
+    cd.print_unique_cycles(cycles)
+  end
+
+end