nodewrap 0.5.0

data/lib/classtree.rb

@@ -0,0 +1,54 @@
+require 'nodewrap'
+
+class Object
+  def classtree(s = '', prefix = '', obj=self, graphed={})
+    # if Module == obj.class.class then
+    #   s << "included module "
+    # elsif obj.singleton? then
+    #   s << "singleton class "
+    # elsif Class === obj then
+    #   s << "class "
+    # end
+    s << "#{obj}"
+    if graphed[obj] then
+      s << " (*)\n"
+      return s
+    end
+    s << "\n"
+    graphed[obj] = true
+    return if Kernel == obj
+    subtree = (Module === obj) && (obj.real_superclass)
+    s << "#{prefix}#{subtree ? '|-' : '+-'}class = "
+    classtree(s, prefix + (subtree ? '| ' : '  '), obj.real_class, graphed)
+    if subtree then
+      s << "#{prefix}+-super = "
+      classtree(s, prefix + '  ', obj.real_superclass, graphed)
+    end
+    return s
+  end
+end
+
+if __FILE__ == $0 then
+  module M
+  end
+
+  class Foo
+    class << self; end
+    include M
+  end
+
+  class Bar < Foo
+  end
+
+  class Baz
+    class << self; @foo = 1; end
+    def self.foo; end
+  end
+
+  b = Bar.new
+  b.classtree($stderr)
+
+  b = Baz.new
+  b.classtree($stderr)
+end
+

data/lib/methodsig.rb

@@ -0,0 +1,266 @@
+require 'nodewrap'
+require 'as_expression'
+
+module MethodSig
+  # Return the names of the arguments this method takes, in the order in
+  # which they appear in the argument list.
+  def argument_names
+    if self.body.respond_to?(:tbl) then
+      # pre-YARV
+      return self.body.tbl || []
+    else
+      # YARV
+      iseq = self.body.body
+      local_vars = iseq.local_table
+      has_rest_arg = iseq.arg_rest != -1
+      has_block_arg = iseq.arg_block != -1
+      num_args = \
+        iseq.argc + \
+        iseq.arg_opt_table.size + \
+        (has_rest_arg ? 1 : 0) + \
+        (has_block_arg ? 1 : 0)
+      return local_vars[0...num_args]
+    end
+  end
+
+  def args_node
+    if self.body.respond_to?(:next)
+      # pre-YARV
+      if self.body.next.class == Node::ARGS then
+        return self.body.next
+      elsif self.body.next.head.class == Node::ARGS then
+        return self.body.next.head
+      else
+        raise "Could not find method arguments"
+      end
+    else
+      # YARV
+      return nil
+    end
+  end
+  private :args_node
+
+  # If this method has a "rest" argument, that is, it has an argument
+  # that is preceded by an asterisk (*) in the argument list, then
+  # return its index, otherwise return nil.
+  def rest_arg
+    args_node = args_node()
+    if args_node then
+      # pre-YARV
+      rest = args_node.rest()
+      if rest.class == Node::LASGN then
+        # subtract 2 to account for implicit vars
+        return rest.cnt - 2
+      elsif not rest
+        return nil
+      else
+        return rest > 0 ? rest - 2 : nil
+      end
+    else
+      # YARV
+      rest = self.body.body.arg_rest
+      return rest >= 0 ? rest - 1: nil
+    end
+  end
+
+  # If this method has a "block" argument, that is, it has an argument
+  # that is preceded by an ampersand (&) in the argument list, then
+  # return its index, otherwise return nil.
+  def block_arg
+    if self.body.respond_to?(:next) then
+      # pre-YARV
+      block = self.body.next
+      if block.class == Node::BLOCK and
+         block.next.head.class == Node::BLOCK_ARG then
+        # subtract 2 to account for implicit vars
+        return block.next.head.cnt - 2
+      else
+        return nil
+      end
+    else
+      # YARV
+      arg_block = self.body.body.arg_block
+      return arg_block >= 0 ? arg_block - 1 : nil
+    end
+  end
+
+  def set_optional_arg_info(info, args_node, names)
+    if args_node then
+      # pre-YARV
+      opt = args_node.opt
+      while opt do
+        head = opt.head
+        if head.class == Node::LASGN then
+          info[head.vid] = "#{head.vid}=#{head.value.as_expression}"
+        else
+          raise "Unexpected node type: #{opt.class}"
+        end
+        opt = opt.next
+      end
+    else
+      # YARV
+      iseq = self.body.body
+      opt_pc = iseq.opt_pc
+      env = Nodewrap::ByteDecoder::Environment.new(iseq.local_table())
+      iseq.bytedecode(env, 0, opt_pc)
+      expressions = env.expressions + env.stack
+      expressions.sort!
+      opt_table = self.body.body.arg_opt_table
+      opt_table.pop
+      first_opt_idx =
+        names.size -
+        opt_table.size -
+        (self.rest_arg ? 1 : 0) -
+        (self.block_arg ? 1 : 0)
+      opt_table.each_with_index do |pc, idx|
+        name = names[first_opt_idx + idx]
+        expr = expressions.find { |e| e.pc >= pc }
+        info[name] = "#{name}=#{expr.rhs}"
+      end
+    end
+  end
+  private :set_optional_arg_info
+
+  # Return a hash mapping each argument name to a description of that
+  # argument.
+  def argument_info
+    names = self.argument_names()
+    block_arg = self.block_arg()
+
+    info = {}
+    names.each do |name|
+      info[name] = name.to_s
+    end
+
+    # Optional args
+    args_node = args_node()
+    set_optional_arg_info(info, args_node, names)
+
+    # Rest arg
+    if self.rest_arg then
+      rest_name = names[rest_arg]
+      info[rest_name] = "*#{rest_name}"
+    end
+
+    # Block arg
+    if block_arg then
+      block_name = names[block_arg]
+      info[block_name] = "&#{block_name}"
+    end
+
+    return info
+  end
+
+  # An abstraction for a method signature.
+  class Signature
+    attr_reader :origin_class, :name, :arg_names, :arg_info
+
+    def initialize(origin_class, name, arg_names, arg_info)
+      @origin_class = origin_class
+      @name = name
+      @arg_names = arg_names
+      @arg_info = arg_info
+    end
+
+    def to_s
+      params = @arg_names.map{ |n| arg_info[n] }
+      return "#{@origin_class}\##{@name}(#{param_list})"
+    end
+
+    def param_list
+      params = @arg_names.map{ |n| arg_info[n] }
+      return params.join(', ')
+    end
+  end
+
+  # An abstraction for a method origin.
+  class Origin
+    attr_reader :file, :line
+
+    def initialize(file, line)
+      @file = file
+      @line = line
+    end
+
+    def to_s
+      return "#{file}:#{line}"
+    end
+  end
+
+  # Return a Method::Origin representing where the method was defined.
+  def origin
+    block = body().next
+    return Origin.new(block.nd_file, block.nd_line)
+  end
+end
+
+class Method
+  include MethodSig
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        origin_class() || attached_class(),
+        method_oid().to_s,
+        argument_names(),
+        argument_info)
+  end
+end
+
+class UnboundMethod
+  include MethodSig
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        nil,
+        method_oid().to_s,
+        argument_names(),
+        argument_info)
+  end
+end
+
+if __FILE__ == $0 then
+  require 'nodewrap'
+
+  def foo(); end
+  puts method(:foo).signature
+
+  def foo(foo); end
+  puts method(:foo).signature
+
+  def foo(foo, bar); end
+  puts method(:foo).signature
+
+  def foo(foo=42, bar=10); end
+  puts method(:foo).signature
+
+  def foo(*args); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=42, *args, &block); end
+  puts method(:foo).signature
+  puts method(:foo).origin
+
+  def foo(foo, bar=obj.foo(1, 2, foo(10)), *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=obj.foo(1 + 1), *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=true ? false : 0, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=true, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=nil, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar={1=>2}, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=[1,2], *args, &block); end
+  puts method(:foo).signature
+end
+

data/lib/node_to_a.rb

@@ -0,0 +1,34 @@
+class Node
+
+  class ARRAY < Node
+    def to_a
+      a = []
+      e = self
+      while e do
+        a << e.head
+        e = e.next
+      end
+      a
+    end
+  end
+
+  class ZARRAY < Node
+    def to_a
+      []
+    end
+  end
+
+  class BLOCK < Node
+    def to_a
+      a = []
+      e = self
+      while e do
+        a << e.head
+        e = e.next
+      end
+      a
+    end
+  end
+
+end
+

data/lib/nodepp.rb

@@ -0,0 +1,71 @@
+# Require this file to get a node pretty-printer.
+#
+
+require 'nodewrap'
+require 'pp'
+
+module Noex
+  # Return a string representing the given integer as a noex value.
+  #
+  def stringify(noex)
+    Noex.constants.each do |constant|
+      return constant.to_s if const_get(constant) == noex
+    end
+    return noex.to_s
+  end
+  module_function :stringify
+end
+
+class Node
+  # Return a string containing an ascii-art tree of the node's
+  # structure.
+  #
+  def tree(s = '', prefix = '')
+    s << "NODE_#{self.nd_type.to_s} at #{self.nd_file}:#{self.nd_line}\n"
+    self.members.each_with_index do |member, idx|
+      last = (idx == self.members.size-1)
+      s << "#{prefix}#{(last ? '+-' : '|-')}#{member} = "
+      value = self[member]
+      if Node === value then
+        value.tree(s, prefix + (last ? '  ' : '| '))
+      elsif Object.const_defined?(:VM) and
+            VM.const_defined?(:InstructionSequence) and
+            VM::InstructionSequence === value then
+        s << "<ISeq:#{value.self.name}@#{value.self.filename}>\n"
+        d = value.disasm
+        lines = d.split("\n")
+        lines.each_with_index do |line, idx|
+          if line =~ /^== disasm: (.*?)=/ then line = $1; end
+          if line =~ /(.*)\s+\(\s*\d+\)/ then line = $1; end
+          next if line =~ /^\|-----/
+          last_line = (idx == lines.size-1)
+          s << "#{prefix}#{last ? '  ' : '| '}#{(last_line ? '+-' : '|-')}#{line}\n"
+        end
+        # p value.local_table
+      elsif member == 'noex' then
+        s << Noex.stringify(value) + "\n"
+      else
+        s << value.inspect + "\n"
+      end
+    end
+    return s
+  end
+
+  # Pretty-print node using Node#tree onto s, which can be a String or
+  # IO.
+  #
+  def pretty_print(pp)
+    pp.text(tree())
+  end
+end
+
+if __FILE__ == $0 then
+  def foo # :nodoc:
+    1 + 1
+  end
+
+  m = method(:foo)
+  n = m.body
+  puts n.pretty_print
+end
+

data/lib/nwdebug.rb

@@ -0,0 +1,18 @@
+require 'nodewrap'
+require 'as_expression'
+
+require 'pp'
+require 'nodepp'
+
+module Nodewrap
+  def printdebug(&block)
+    puts "#{caller[0]}: #{block.body.as_expression} => #{block.call}"
+  end
+end
+
+if __FILE__ == $0 then
+  include Nodewrap
+  a = 41
+  printdebug { a + 1 }
+end
+

data/lib/nwdump.rb

@@ -0,0 +1,53 @@
+# This is a script similar to the Pragmatic Programmers' NodeDump.so.
+# You can use it similarly, e.g.:
+#
+#   $ cat test.rb
+#   def foo
+#     1+1
+#   end
+#
+#   $ ruby -rnwdump test.rb
+#   NODE_NEWLINE at test.rb:1
+#   |-nth = 1
+#   +-next = NODE_DEFN at test.rb:1
+#     |-defn = NODE_SCOPE at test.rb:3
+#     | |-rval = false
+#     | |-tbl = nil
+#     | +-next = NODE_BLOCK at test.rb:1
+#     |   |-next = NODE_BLOCK at test.rb:3
+#     |   | |-next = false
+#     |   | +-head = NODE_NEWLINE at test.rb:2
+#     |   |   |-nth = 2
+#     |   |   +-next = NODE_CALL at test.rb:2
+#     |   |     |-recv = NODE_LIT at test.rb:2
+#     |   |     | +-lit = 1
+#     |   |     |-args = NODE_ARRAY at test.rb:2
+#     |   |     | |-alen = 1
+#     |   |     | |-head = NODE_LIT at test.rb:2
+#     |   |     | | +-lit = 1
+#     |   |     | +-next = false
+#     |   |     +-mid = :+
+#     |   +-head = NODE_ARGS at test.rb:1
+#     |     |-cnt = 0
+#     |     |-rest = -1
+#     |     +-opt = false
+#     |-mid = :foo
+#     +-noex = PRIVATE
+
+require 'nodepp'
+
+set_trace_func proc {
+  begin
+    n = $ruby_eval_tree
+    if defined?($ruby_eval_tree_begin) and $ruby_eval_tree_begin then
+      pp $ruby_eval_tree_begin, $stderr
+    end
+    if n then
+      PP.pp n, $stderr
+      exit!
+    end
+  rescue Exception
+    p $!, $!.backtrace
+  end
+}
+