ZenHacks 1.0.0

data/History.txt

@@ -0,0 +1,4 @@
+*** 1.0.0 / 2005-05-24
+ 
++ 1 major enhancement
+ 	+ Birthday!

data/Manifest.txt

@@ -0,0 +1,29 @@
+History.txt
+Manifest.txt
+README.txt
+bin/macgraph
+bin/parse_tree_graph
+bin/test_stats
+fixloops-demo.sh
+lib/OrderedHash.rb
+lib/class-path.rb
+lib/discover.rb
+lib/fixloops.rb
+lib/graph.rb
+lib/muffdaddy.rb
+lib/r2c_hacks.rb
+lib/ruby2ruby.rb
+lib/timezones.rb
+lib/zendebug.rb
+lib/zenoptimize.rb
+lib/zenprofile.rb
+misc/factorial.rb
+misc/find_c_methods
+misc/fixloops-bad.rb
+r2c_hacks-demo.rb
+test/TestOrderedHash.rb
+test/r2ctestcase.rb
+test/test_parse_tree_graph.rb
+zendebug-demo.sh
+zenoptimize-demo.sh
+zenprofile-demo.sh

data/README.txt

@@ -0,0 +1,84 @@
+ZenHacks
+    http://rubyforge.org/projects/zenhacks/
+    ryand-ruby@zenspider.com
+
+** DESCRIPTION:
+  
+ZenHacks is a semi-random collection of libs and scripts that just
+don't belong in a package of their own. Many, if not most, have
+dependencies on other packages and use, abuse, or extend them in
+interesting ways.
+
+This package is not supported in the same sense that my other packages
+are, but since it is such a fun playground, I am very open to
+contributions, suggestions, and bug fixes. I just can't put this
+project at the top of my priority list the way I can/do the others, so
+it may take me longer to get to than normal.
+
+** INCLUDES
+
++ RubyInline Hacks
+	+ zenprofile-demo.sh - demonstrates the use of zenprofile.
+	+ lib/zenprofile.rb - a code profiler that is fairly readable yet fast.
++ ParseTree Hacks
+	+ bin/parse_tree_graph - graphs parsetree for code fed to it.
+	+ test/test_parse_tree_graph.rb - tests for parse_tree_graph.
++ RubyToRuby Hacks
+	+ fixloops-demo.sh - demonstrates using parsetree to analyze source.
+	+ lib/fixloops.rb - simple loop analyzer and refactoring tool.
+	+ misc/fixloops-bad.rb - demo code for fixloops-demo.sh.
+	+ lib/ruby2ruby.rb - converts ParseTree's sexp back into ruby.
++ RubyToC Hacks
+	+ r2c_hacks-demo.rb - demonstrates r2c_hacks' methods.
+	+ lib/r2c_hacks.rb - implements to_sexp, to_ruby, and to_c for methods.
+	+ zenoptimize-demo.sh - demonstrates dynamic optimization of ruby.
+	+ lib/zenoptimize.rb - implements a dynamic optimizer using ruby2c.
++ Testing Hacks
+	+ bin/test_stats - shows ratio of assertions to methods
++ Misc Hacks
+	+ misc/factorial.rb - not a hack, but a demo file for above toys.
+	+ misc/find_c_methods - sniffs through ruby's C to find C methods.
+	+ lib/class-path.rb - returns array of each level of a class' namespace.
+	+ lib/discover.rb - requires files and returns classes introduced.
+	+ lib/muffdaddy.rb - allows you to very easily wrap objects and classes.
+	+ lib/graph.rb - very simple / clean api for building w/ graphviz.
+	+ bin/macgraph - very stupid / ugly frontend for using graphviz on osx.
+	+ lib/OrderedHash.rb - a simple Hash with ordered keys.
+	+ test/TestOrderedHash.rb - (bad) tests for OrderedHash.
+	+ OrderedHash.rb/TestOrderedHash.rb - Orderered keyed collection.
+	+ lib/timezones.rb - fixes the fact that you can't get timezones from Time.
+
+** REQUIREMENTS:
+
+Lots... RubyInline, Ruby2C, ParseTree. Probably others. Not all
+dependencies are required for all hacks. There may be some tweaking
+needed to run the demo.sh files.
+
+** INSTALL:
+
++ No install, this is mostly for playing and/or reading.
+
+** LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2001-2005 Ryan Davis, Zen Spider Software
+
+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/bin/macgraph

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# set -x
+
+PATH=$PATH:/Applications/Graphviz.app/Contents/MacOS/
+
+f1=/tmp/graph.$$.dot
+f2=/tmp/graph.$$.pdf
+if [ $1 == '-f' ]; then
+    shift 1
+    echo $* | GEM_SKIP=ParseTree ruby -Ilib bin/parse_tree_graph -f -a > $f1
+else
+    GEM_SKIP=ParseTree ruby -Ilib bin/parse_tree_graph $* > $f1
+fi
+dot -Tepdf $f1 > $f2
+open $f2
+(sleep 10; rm -f $f1 $f2) &
+

data/bin/parse_tree_graph

@@ -0,0 +1,161 @@
+#!/usr/local/bin/ruby -ws
+
+$TESTING = false unless defined? $TESTING
+require 'pp'
+require 'tempfile'
+
+def usage(exit_code = 0)
+  cmd = File.basename($0)
+  puts "#{cmd} [options] files|libs"
+  puts "  options:"
+  puts "    -h show help"
+  puts "    -f fast mode - graph a snippet of code from standard input"
+  puts "    -a color ABC nodes"
+  puts "    -s graph basic structure only"
+  exit exit_code
+end
+
+usage if defined? $h
+
+
+#begin
+#  require 'rubygems'
+#  require_gem 'ParseTree'
+#rescue LoadError
+  require 'parse_tree'
+#end
+
+require 'sexp_processor'
+
+def discover_new_classes_from
+  old_classes = []
+  ObjectSpace.each_object(Module) do |klass|
+    old_classes << klass
+  end
+
+  yield
+
+  new_classes = []
+  ObjectSpace.each_object(Module) do |klass|
+    new_classes << klass
+  end
+
+  new_classes - old_classes
+end
+
+$f = false unless defined? $f
+
+new_classes = discover_new_classes_from do
+  ARGV.unshift "-" if ARGV.empty?
+  ARGV.each do |name|
+    if name == "-" then
+      code = $stdin.read
+      code = "class Example; def example; #{code}; end; end" if $f
+      eval code unless code.nil?
+    else
+      require name
+    end
+  end
+end unless $TESTING
+
+require 'graph'
+
+class SexpGrapher < SexpProcessor
+
+  attr_reader :graph
+  def initialize
+    super
+    self.default_method = :grapher
+    self.warn_on_default = false
+    @stack = []
+    @graph = Graph.new
+    @graph.prefix << "   node [ shape = box, style = filled ];"
+    @abc = defined? $a
+    @n = 1
+  end
+
+  ##
+  # Create a DOT graph of the parse tree
+  #
+  # For example:
+  #
+  #   [:call, [:lit, 1], :+, [:array, [:lit, 1]]]
+  #
+  # at start of exp, push :call onto stack
+  # process :call
+  # recurse into :lit
+  # at start of exp, push :lit onto stack
+  # process :lit
+  # process 1
+  # 
+
+  def convert_node(n)
+    node = "n%04d" % @n
+    @n += 1
+    @graph.attribs[node]<<"label = \"#{n.inspect.gsub('"', '\\"')}\""
+    node
+  end
+
+  def color_node(node_type, current)
+    color = case node_type
+            when :attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn then
+              "lightblue"
+            when :and, :case, :else, :if, :iter, :or, :rescue, :until, :when, :while then
+              "palegreen"
+            when :call, :fcall, :super, :vcall, :yield then
+              "goldenrod"
+            else
+              nil
+            end
+    @graph.attribs[current] << "color = #{color.inspect}" unless color.nil?
+  end
+
+  def grapher(exp)
+    current = nil
+    previous = @stack.last
+
+    unless Array === exp.first then
+      node_type = exp.shift
+      current = convert_node(node_type)
+      color_node(node_type, current) if @abc
+      @graph[previous] << current unless previous.nil?
+      @stack.push current
+    end
+
+    previous = current
+
+    until exp.empty? do
+      current = exp.shift
+      if Array === current then
+        process(current)
+        previous = @stack.last
+      else
+        node_type = current
+        current = convert_node(current)
+        @graph[previous] << current unless previous.nil?
+        previous = current
+      end
+    end
+    @stack.pop
+    s() # junk return
+  end
+
+  def graphstr
+    @graph.to_s
+  end
+end
+
+if __FILE__ == $0 then
+  result = ParseTree.new.parse_tree(*new_classes)
+  if $f then
+    result = result[0][3][2][1] # extracts just the body of the example method
+    result.shift
+    result.shift
+  end
+
+  result = Sexp.from_array(result)
+  grapher = SexpGrapher.new
+  result = result.structure if defined? $s
+  grapher.process(result)
+  puts grapher.graphstr
+end

data/bin/test_stats

@@ -0,0 +1,42 @@
+#!/usr/local/bin/ruby -w
+
+assert_count = {}
+def_count = {}
+result = []
+
+assert_count.default = 0
+def_count.default = 0
+
+current_class = "unknown"
+
+ARGF.each_line do |l|
+
+  current_class = $1 if l =~ /^\s*class\s+(\S+)/
+  def_count[current_class]    += 1 if l =~ /^\s*def/
+  assert_count[current_class] += 1 if l =~ /assert_|flunk|fail/
+
+end
+
+def_count.each_key do |classname|
+
+  entry = {}
+
+  next if classname =~ /^Test/
+  testclassname = "Test#{classname}"
+  a_count = assert_count[testclassname]
+  d_count = def_count[classname]
+  ratio = a_count.to_f / d_count.to_f * 100.0
+
+  entry['n'] = classname
+  entry['r'] = ratio
+  entry['a'] = a_count
+  entry['d'] = d_count
+
+  result.push entry
+end
+
+sorted_results = result.sort { |a,b| b['r'] <=> a['r'] }
+
+sorted_results.each do |e|
+  printf "# %25s: %4d defs %4d = %6.2f%%\n", e['n'], e['d'], e['a'], e['r']
+end

data/fixloops-demo.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+GEM_SKIP=ParseTree ruby -Ilib:../../ParseTree/dev/lib:../../ruby_to_c/dev:. -w misc/fixloops-bad.rb

data/lib/OrderedHash.rb

@@ -0,0 +1,37 @@
+
+class OrderedHash < Hash
+  
+  def initialize(default=nil)
+    super(default)
+    @order = []
+  end
+
+  def []=(key,val)
+    @order.delete(key)
+    @order.push(key)
+    super(key,val)
+  end
+
+  def keys
+    @order
+  end
+
+  def each
+    @order.each do |key|
+      yield(key, self[key])
+    end
+  end
+
+  def each_key
+    @order.each do |key|
+      yield(key)
+    end
+  end
+
+  def each_value
+    @order.each do |key|
+      yield(self[key])
+    end
+  end
+
+end

data/lib/class-path.rb

@@ -0,0 +1,20 @@
+#!/usr/local/bin/ruby -w
+
+class Class
+  def path
+    result = []
+    self.name.split(/::/).inject(Object) do |c, n|
+      result << c.const_get(n)
+      result.last
+    end
+    return result
+  end
+end
+
+class Foo
+  class Bar
+  end
+end
+
+p Foo::Bar.path
+# => [Foo, Foo::Bar]

data/lib/discover.rb

@@ -0,0 +1,15 @@
+def discover_new_classes_from
+  old_classes = []
+  ObjectSpace.each_object(Module) do |klass|
+    old_classes << klass
+  end
+
+  yield
+
+  new_classes = []
+  ObjectSpace.each_object(Module) do |klass|
+    new_classes << klass
+  end
+
+  new_classes - old_classes
+end

data/lib/fixloops.rb

@@ -0,0 +1,79 @@
+require 'parse_tree'
+require 'ruby2ruby'
+
+class Refax
+
+  def couldPossiblyRefactor?(p, ind)
+    return false unless p[ind].is_a?(Array)
+    return false unless p[ind].first == :while
+    return false if p[ind][-1] == :post
+    return true unless p[ind][2].is_a?(Array)
+    p[ind][2].first == :block
+  end
+
+  def howManyInsn(p)
+    fail "Must be a while, not a #{p}" unless p.first == :while
+    if p[2].is_a?(Array)
+      fail unless p[2].first == :block
+      p[2].size - 1
+    else
+      1
+    end
+  end
+
+  def grabInsnArray(p)
+    fail "Must be a while, not a #{p}" unless p[0] == :while
+      if p[2].is_a?(Array)
+        p[2][1..-1]
+      else
+        [p[2]]
+      end
+  end
+
+  def isEquiv(a, b)
+    a.to_s == b.to_s
+  end
+
+  def fixcode(p, ind)
+    loopsize = howManyInsn(p[ind])
+    goodcode = p.clone
+    goodcode[ind][-1] = ! goodcode[ind][-1] #true # false
+    goodcode.slice!(ind-loopsize..ind-1)
+    goodcode # todo : make correcter
+  end
+
+  def recurseOn(p)
+    if p.is_a?(Array)
+      @lastclass = p[1] if p.first == :class
+      @lastfunc = p[1] if p.first == :defn
+      p.each { |i| recurseOn(i) }
+      p.each_index do |ind|
+        if couldPossiblyRefactor?(p,ind)
+          loopsize = howManyInsn(p[ind])
+          if loopsize < ind
+            if isEquiv(p[ind-loopsize,loopsize], grabInsnArray(p[ind]))
+              goodstuff = fixcode(p, ind)
+              puts "Suggest refactoring #{@lastclass}##{@lastfunc} from:"
+              puts 
+              puts RubyToRuby.translate(eval(@lastclass.to_s), @lastfunc)
+              print "\nto:\n\n"
+              puts RubyToRuby.new.process(s(:defn, @lastfunc, s(:scope, goodstuff)))
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def refactor(c)
+    fail "Must have class or module" unless c.is_a?(Module)
+    p = ParseTree.new.parse_tree(c)
+    recurseOn(p)
+  end
+
+  r = Refax.new
+  ObjectSpace.each_object(Module) { |c|
+    r.refactor(c)
+  }
+
+end