ZenHacks 1.0.0

data/lib/graph.rb

@@ -0,0 +1,66 @@
+#!/usr/local/bin/ruby -w
+
+class Graph < Hash
+
+  attr_reader :attribs
+  attr_reader :prefix
+  attr_reader :order
+  def initialize(name="a_graph")
+    super() { |h,k| h[k] = [] }
+    @name = name
+    @prefix = []
+    @attribs = Hash.new { |h,k| h[k] = [] }
+    @order = []
+  end
+
+  def []=(key, val)
+    @order << key unless self.has_key? key
+    super(key, val)
+  end
+
+  def each_pair
+    @order.each do |from|
+      self[from].each do |to|
+        yield(from, to)
+      end
+    end
+  end
+
+  def invert
+    result = self.class.new
+    each_pair do |from, to|
+      result[to] << from
+    end
+    result
+  end
+
+  def counts
+    result = Hash.new(0)
+    each_pair do |from, to|
+      result[from] += 1
+    end
+    result
+  end
+
+  def keys_by_count
+    counts.sort_by { |x,y| y }.map {|x| x.first }
+  end
+
+  def to_s
+    result = []
+    result << "digraph #{@name}"
+    result << "  {"
+    @prefix.each do |line|
+      result << line
+    end
+    @attribs.sort.each do |node, attribs|
+      result << "    #{node.inspect} [ #{attribs.join(',')} ]"
+    end
+    each_pair do |from, to|
+      result << "    #{from.inspect} -> #{to.inspect};"
+    end
+    result << "  }"
+    result.join("\n")
+  end
+
+end

data/lib/muffdaddy.rb

@@ -0,0 +1,84 @@
+#!/usr/local/bin/ruby -w
+
+# the ultimate "rapper"
+module MuffDaddy
+  def self.__rap_method__(c, m)
+    return if m =~ /^__/
+    c = class << c; self; end unless c.class == Class
+    return if c.instance_methods(false).include? "__#{m}"
+    rapped_method = c.const_get("RAP_METHOD_NAME")
+    c.class_eval "alias __#{m} #{m}"
+    c.class_eval "def #{m}(*args); #{rapped_method} { __#{m}(*args) }; end"
+  end
+
+  def self.__rap_class__(c)
+    c.instance_methods(false).each { |m| __rap_method__(c, m) }
+    c.class_eval "def self.method_added(m); MuffDaddy.__rap_method__(self, m.to_s); end"
+  end
+
+  def self.__rap_object__(o)
+    o.public_methods(false).each { |m| __rap_method__(o, m) }
+  end
+
+  def self.extend_object(o)
+    super(o)
+    MuffDaddy.__rap_object__(o)
+  end
+
+  def self.included(c)
+    super(c)
+    if c.class == Module then
+      c.module_eval "def self.included(c); super(c); MuffDaddy.included(c); end"
+      c.module_eval "def self.extend_object(c); super(c); MuffDaddy.extend_object(c); end"
+    end
+    MuffDaddy.__rap_class__(c)
+  end
+end
+
+module CheapoTracer
+
+  include MuffDaddy
+
+  RAP_METHOD_NAME = :__trace__
+
+  def __trace__
+    @__trace = 0 unless defined? @__trace
+    print "  " * @__trace
+    print "#{@__trace}: "
+    @__trace += 1
+    yield
+    @__trace -= 1
+  end
+
+end
+
+class Untraced
+  def something
+    puts "Miiiiisery!"
+    something_else
+  end
+
+  def something_else
+    puts "Decay!"
+  end
+end
+
+class Traced
+  include CheapoTracer
+
+  def method1
+    puts "I'm dead too!"
+  end
+end
+
+w1 = Untraced.new
+w1.something
+
+w1.extend CheapoTracer
+w1.something
+
+w2 = Untraced.new
+w2.something
+
+w3 = Traced.new
+w3.method1

data/lib/r2c_hacks.rb

@@ -0,0 +1,36 @@
+#require 'rubygems'
+#require_gem 'ParseTree'
+require 'parse_tree'
+require 'sexp_processor'
+require 'ruby_to_c'
+require 'ruby2ruby'
+
+class Method
+  def with_class_and_method_name
+    if self.inspect =~ /<Method: (.*)\#(.*)>/ then
+      klass = eval $1
+      method  = $2.intern
+      return yield(klass, method)
+    else
+      raise "Can't parse signature: #{self.inspect}"
+    end
+  end
+
+  def to_sexp
+    with_class_and_method_name do |klass, method|
+      ParseTree.new.parse_tree_for_method(klass, method)
+    end
+  end
+
+  def to_c
+    with_class_and_method_name do |klass, method|
+      RubyToC.translate(klass, method)
+    end
+  end
+
+  def to_ruby
+    with_class_and_method_name do |klass, method|
+      RubyToRuby.translate(klass, method)
+    end
+  end
+end

data/lib/ruby2ruby.rb

@@ -0,0 +1,306 @@
+require 'parse_tree'
+require 'support'
+require 'sexp_processor'
+
+class RubyToRuby < SexpProcessor
+
+  def self.translate(klass, method=nil)
+    unless method.nil? then
+      self.new.process(ParseTree.new.parse_tree_for_method(klass, method))
+    else
+      self.new.process(ParseTree.new.parse_tree(klass).first) # huh? why is the :class node wrapped?
+    end
+  end
+
+  def initialize
+    super
+    @env = Environment.new
+    @indent = "  "
+    self.auto_shift_type = true
+    self.strict = true
+    self.expected = String
+  end
+  
+  def indent(s)
+    s.to_s.map{|line| @indent + line}.join
+  end
+  
+  def process_and(exp)
+    "(#{process exp.shift} and #{process exp.shift})"
+  end
+  
+  def process_args(exp)
+    args = []
+
+    until exp.empty? do
+      arg = exp.shift
+      if arg.is_a? Array
+        args[-(arg.size-1)..-1] = arg[1..-1].map{|a| process a}
+      else
+        args << arg
+      end
+    end
+
+    return "(#{args.join ', '})"
+  end
+  
+  def process_array(exp)
+    code = []
+    until exp.empty? do
+      code << process(exp.shift)
+    end
+    return "[" + code.join(", ") + "]"
+  end
+
+  def process_attrasgn(exp)
+    process_call(exp)
+  end
+
+  def process_block(exp)
+    code = []
+    until exp.empty? do
+      code << process(exp.shift)
+    end
+
+    body = code.join("\n")
+    body += "\n"
+
+    return body
+  end
+
+  def process_call(exp)
+    receiver = process exp.shift
+    name = exp.shift
+    args_exp = exp.shift
+    if args_exp && args_exp.first == :array
+      args = "#{process(args_exp)[1..-2]}"
+    else
+      args = process args_exp
+    end
+
+    case name
+    when :<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :% then #
+      "(#{receiver} #{name} #{args})"
+    when :[] then
+      "#{receiver}[#{args}]"
+    else
+      "#{receiver}.#{name}#{args ? "(#{args})" : args}"
+    end
+  end
+  
+  def process_case(exp)
+    s = "case #{process exp.shift}\n"
+    until exp.empty?
+      pt = exp.shift
+      if pt.first == :when
+        s << "#{process(pt)}\n"
+      else
+        s << "else\n#{indent(process(pt))}\n"
+      end
+    end
+    s + "\nend"
+  end
+  
+  def process_class(exp)
+    s = "class #{exp.shift} < #{exp.shift}\n"
+    body = ""
+    body << "#{process exp.shift}\n\n" until exp.empty?
+    s + indent(body) + "end"
+  end
+
+  def process_const(exp)
+    exp.shift.to_s
+  end
+  
+  def process_dasgn_curr(exp)
+    exp.shift.to_s
+  end
+  
+  def process_defn(exp)
+    name = exp.shift
+    args = process(exp.shift).to_a
+    args[1..-1] = indent(args[1..-1])
+    args.join
+    body = indent(process(exp.shift))
+    return "def #{name}#{args}#{body}end".gsub(/\n\s*\n+/, "\n")
+  end
+  
+  def process_dot2(exp)
+    "(#{process exp.shift}..#{process exp.shift})"
+  end
+
+  def process_dot3(exp)
+    "(#{process exp.shift}...#{process exp.shift})"
+  end
+  
+  def process_dstr(exp)
+    s = exp.shift.dump[0..-2]
+    until exp.empty?
+      pt = exp.shift
+      if pt.first == :str
+        s << process(pt)[1..-2]
+      else
+        s << '#{' + process(pt) + '}'
+      end
+    end
+    s + '"'
+  end
+
+  def process_dvar(exp)
+    exp.shift.to_s
+  end
+
+  def process_false(exp)
+    "false"
+  end
+  
+  def process_fcall(exp)
+    exp_orig = exp.deep_clone
+    # [:fcall, :puts, [:array, [:str, "This is a weird loop"]]]
+    name = exp.shift.to_s
+    args = exp.shift
+    code = []
+    unless args.nil? then
+      assert_type args, :array
+      args.shift # :array
+      until args.empty? do
+        code << process(args.shift)
+      end
+    end
+    return "#{name}(#{code.join(', ')})"
+  end
+  
+  def process_iasgn(exp)
+    "#{exp.shift} = #{process exp.shift}"
+  end
+  
+  def process_if(exp)
+    s = ["if (#{process exp.shift})"]
+    s << "#{indent(process(exp.shift))}"
+    s << "else\n#{indent(process(exp.shift))}" until exp.empty?
+    s << "end"
+    s.join("\n")
+  end
+  
+  def process_iter(exp)
+    "#{process exp.shift} {|#{process exp.shift}|\n" +
+    indent("#{process exp.shift}\n") +
+    "}"
+  end
+  
+  def process_ivar(exp)
+    exp.shift.to_s
+  end
+  
+  def process_lasgn(exp)
+    return "#{exp.shift} = #{process exp.shift}"
+  end
+  
+  def process_lit(exp)
+    obj = exp.shift
+    if obj.is_a? Range # to get around how parsed ranges turn into lits and lose parens
+      "(" + obj.inspect + ")"
+    else
+      obj.inspect
+    end
+  end
+  
+  def process_lvar(exp)
+    exp.shift.to_s
+  end
+  
+  def process_masgn(exp)
+    process(exp.shift)[1..-2]
+  end
+
+  def process_nil(exp)
+    "nil"
+  end
+  
+  def process_return(exp)
+    return "return #{process exp.shift}"
+  end
+
+  def process_scope(exp)
+    return process(exp.shift)
+  end
+
+  def process_self(exp)
+    "self"
+  end
+  def process_str(exp)
+    return exp.shift.dump
+  end
+
+  def process_super(exp)
+    "super(#{process(exp.shift)})"
+  end
+  
+  def process_true(exp)
+    "true"
+  end
+
+  def process_until(exp)
+    cond_loop(exp, 'until')
+  end
+  
+  def process_vcall(exp)
+    return exp.shift.to_s
+  end
+  
+  def process_when(exp)
+    "when #{process(exp.shift).to_s[1..-2]}\n#{indent(process(exp.shift))}"
+  end
+
+  def process_while(exp)
+    cond_loop(exp, 'while')
+  end
+  
+  def process_zarray(exp)
+    "[]"
+  end
+
+  def process_zsuper(exp)
+    "super"
+  end
+  
+  def cond_loop(exp, name)
+    cond = process(exp.shift)
+    body = indent(process(exp.shift))
+    head_controlled = exp.empty? ? false : exp.shift
+
+    code = []
+    if head_controlled then
+      code << "#{name} #{cond} do"
+      code << body
+      code << "end"
+    else
+      code << "begin"
+      code << body
+      code << "end #{name} #{cond}"
+    end
+    code.join("\n")
+  end
+  
+end
+
+if __FILE__ == $0
+  r2r2r = RubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
+  eval r2r2r
+
+  class RubyToRubyToRuby
+    class<<self
+      eval RubyToRuby.translate(class<<RubyToRuby;self;end, :translate)
+    end
+    eval RubyToRuby.translate(RubyToRuby, :initialize)
+  end
+  
+  r2r2r2 = RubyToRubyToRuby.translate(RubyToRuby).sub("RubyToRuby","RubyToRubyToRuby")
+  r2r2r2r = RubyToRubyToRuby.translate(RubyToRubyToRuby)
+  # File.open('1','w'){|f| f.write r2r2r}
+  # File.open('2','w'){|f| f.write r2r2r2}
+  # File.open('3','w'){|f| f.write r2r2r2r}
+  raise "Translation failed!" if (r2r2r != r2r2r2) or (r2r2r != r2r2r2r)
+  
+  puts("RubyToRubyToRubyToRubyyyyy!!!")
+end