sorcerer 0.0.1

data/README.textile

@@ -0,0 +1,2 @@
+h1. Sorcerer -- Recovering the Source
+

data/Rakefile

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby"
+
+require 'rake/clean'
+require 'rake/testtask'
+
+begin
+  require 'rubygems'
+  require 'rake/gempackagetask'
+rescue Exception
+  nil
+end
+
+module Config
+  PROJ = 'sorcerer'
+  RUBY = 'ruby19'
+
+  BASE_RDOC_OPTIONS = [
+    '--line-numbers', '--inline-source',
+    '--main' , 'README.rdoc',
+    '--title', 'Rake -- Ruby Make'
+  ]
+end
+
+PKG_VERSION = '0.0.1'
+
+PKG_FILES = FileList[
+  'README.textile',
+  'Rakefile',
+  'doc/*',
+  'rakelib/*',
+  'lib/**/*.rb',
+  'test/**/*.rb',
+]
+  
+
+task :default => :test
+
+# Modify the TestTask to allow running ruby19 for the tests
+class Ruby19TestTask < Rake::TestTask
+  def ruby(*args)
+    sh "#{Config::RUBY} #{args.join(' ')}"
+  end
+end
+
+Ruby19TestTask.new(:test) do |t|
+  t.warning = true
+  t.verbose = false
+  t.test_files = FileList["test/#{Config::PROJ}/*_test.rb"]
+end
+
+if ! defined?(Gem)
+  puts "Package Target requires RubyGEMs"
+else
+  SPEC = Gem::Specification.new do |s|
+    s.name = 'sorcerer'
+    s.version = PKG_VERSION
+    s.summary = "Generate Source from Ripper ASTs"
+    s.description = <<-EOF
+      Generate the original Ruby source from a Ripper-style abstract syntax tree.
+    EOF
+    s.files = PKG_FILES.to_a
+    s.require_path = 'lib'                         # Use these for libraries.
+    s.has_rdoc = true
+    s.rdoc_options = Config::BASE_RDOC_OPTIONS
+    s.author = "Jim Weirich"
+    s.email = "jim.weirich@gmail.com"
+    s.homepage = "http://github.com/jimweirich/sorcerer"
+  end
+
+  package_task = Rake::GemPackageTask.new(SPEC) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+  end
+end

data/lib/sorcerer.rb

@@ -0,0 +1 @@
+require 'sorcerer/sorcerer'

data/lib/sorcerer/sorcerer.rb

@@ -0,0 +1,715 @@
+#!/usr/bin/env ruby
+
+require 'ripper'
+
+class Sorcerer
+  class NoHandlerError < StandardError
+  end
+
+  # Generate the source code for teh given Ripper S-Expression.
+  def Sorcerer.source(sexp, debug=false)
+    new(sexp, debug).source
+  end
+
+  def initialize(sexp, debug=false)
+    @sexp = sexp
+    @source = ''
+    @debug = debug
+    @word_level = 0
+  end
+
+  def source
+    resource(@sexp)
+    @source
+  end
+
+  def resource(sexp)
+    return unless sexp
+    handler = Handlers[sexp.first]
+    raise NoHandlerError.new(sexp.first) unless handler
+    if @debug
+      puts "----------------------------------------------------------"
+      pp sexp
+    end
+    handler.call(self, sexp)
+  end
+
+  def handle_block(sexp)
+    resource(sexp[1])     # Arguments
+    if ! void?(sexp[2])
+      emit(" ")
+      resource(sexp[2])     # Statements
+    end
+    emit(" ")
+  end
+
+  def opt_parens(sexp)
+    emit(" ") unless sexp.first == :arg_paren || sexp.first == :paren
+    resource(sexp)
+  end
+
+  def emit(string)
+    puts "EMITTING '#{string}'" if @debug
+    @source << string
+  end
+
+  def nyi(sexp)
+    raise "Handler for #{sexp.first} not implemented (#{sexp.inspect})"
+  end
+
+  def emit_separator(sep, first)
+    emit(sep) unless first
+    false
+  end
+
+  def params(normal_args, default_args, rest_args, unknown, block_arg)
+    first = true
+    if normal_args
+      normal_args.each do |sx|
+        first = emit_separator(", ", first)
+        resource(sx)
+      end
+    end
+    if default_args
+      default_args.each do |sx|
+        first = emit_separator(", ", first)
+        resource(sx[0])
+        emit("=")
+        resource(sx[1])
+      end
+    end
+    if rest_args
+      first = emit_separator(", ", first)
+      resource(rest_args)
+    end
+    if block_arg
+      first = emit_separator(", ", first)
+      resource(block_arg)
+    end
+  end
+  
+  def words(marker, sexp)
+    emit("%#{marker}{") if @word_level == 0
+    @word_level += 1
+    if sexp[1] != [:qwords_new] && sexp[1] != [:words_new]
+      resource(sexp[1])
+      emit(" ")
+    end
+    resource(sexp[2])
+    @word_level -= 1
+    emit("}") if @word_level == 0
+  end
+
+  VOID_STATEMENT = [:stmts_add, [:stmts_new], [:void_stmt]]
+  VOID_BODY = [:body_stmt, VOID_STATEMENT, nil, nil, nil]
+
+  def void?(sexp)
+    sexp.nil? ||
+      sexp == VOID_STATEMENT ||
+      sexp == VOID_BODY
+  end
+
+  NYI = lambda { |src, sexp| src.nyi(sexp) }
+  DBG = lambda { |src, sexp| pp(sexp) }
+  NOOP = lambda { |src, sexp| }
+  SPACE = lambda { |src, sexp| src.emit(" ") }
+  PASS1 = lambda { |src, sexp| src.resource(sexp[1]) }
+  PASS2 = lambda { |src, sexp| src.resource(sexp[2]) }
+  EMIT1 = lambda { |src, sexp| src.emit(sexp[1]) }
+
+  Handlers = {
+    # parser keywords
+
+    :BEGIN => lambda { |src, sexp|
+      src.emit("BEGIN {")
+      unless src.void?(sexp[1])
+        src.emit(" ")
+        src.resource(sexp[1])
+      end
+      src.emit(" }")
+    },
+    :END => lambda { |src, sexp|
+      src.emit("END {")
+      unless src.void?(sexp[1])
+        src.emit(" ")
+        src.resource(sexp[1])
+      end
+      src.emit(" }")
+    },
+    :alias => lambda { |src, sexp|
+      src.emit("alias ")
+      src.resource(sexp[1])
+      src.emit(" ")
+      src.resource(sexp[2])
+    },
+    :alias_error => NYI,
+    :aref => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit("[")
+      src.resource(sexp[2])
+      src.emit("]")
+    },
+    :aref_field => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit("[")
+      src.resource(sexp[2])
+      src.emit("]")
+    },
+    :arg_ambiguous => NYI,
+    :arg_paren => lambda { |src, sexp|
+      src.emit("(")
+      src.resource(sexp[1]) if sexp[1]
+      src.emit(")")
+    },
+    :args_add => lambda { |src, sexp|
+      src.resource(sexp[1])
+      if sexp[1].first != :args_new
+        src.emit(", ")
+      end
+      src.resource(sexp[2])
+    },
+    :args_add_block => lambda { |src, sexp|
+      src.resource(sexp[1])
+      if sexp[2]
+        if sexp[1].first != :args_new
+          src.emit(", ")
+        end
+        if sexp[2]
+          src.emit("&")
+          src.resource(sexp[2])
+        end
+      end
+    },
+    :args_add_star => lambda { |src, sexp|
+      src.resource(sexp[1])
+      if sexp[1].first != :args_new
+        src.emit(", ")
+      end
+      src.emit("*")
+      src.resource(sexp[2])
+    },
+    :args_new => NOOP,
+    :args_prepend => NYI,
+    :array => lambda { |src, sexp|
+      src.emit("[")
+      src.resource(sexp[1])
+      src.emit("]")
+    },
+    :assign => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" = ")
+      src.resource(sexp[2])
+    },
+    :assign_error => NYI,
+    :assoc_new => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" => ")
+      src.resource(sexp[2])
+    },
+    :assoclist_from_args => lambda { |src, sexp|
+      first = true
+      sexp[1].each do |sx|
+        src.emit(", ") unless first
+        first = false
+        src.resource(sx)
+      end
+    },
+    :bare_assoc_hash => lambda { |src, sexp|
+      first = true
+      sexp[1].each do |sx|      
+        src.emit(", ") unless first
+        first = false
+        src.resource(sx)
+      end
+    },
+    :begin => lambda { |src, sexp|
+      src.emit("begin")
+      src.resource(sexp[1])
+      src.emit("end")
+    },
+    :binary => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" #{sexp[2]} ")
+      src.resource(sexp[3])
+    },
+    :block_var => lambda { |src, sexp|
+      src.emit(" |")
+      src.resource(sexp[1])
+      src.emit("|")
+    },
+    :block_var_add_block => NYI,
+    :block_var_add_star => NYI,
+    :blockarg => lambda { |src, sexp|
+      src.emit("&")
+      src.resource(sexp[1])
+    },
+    :body_stmt => lambda { |src, sexp|
+      src.resource(sexp[1])     # Main Body
+      src.emit("; ")
+      src.resource(sexp[2])   # Rescue
+      src.resource(sexp[4])   # Ensure
+    },
+    :brace_block => lambda { |src, sexp|
+      src.emit(" {")
+      src.handle_block(sexp)
+      src.emit("}")
+    },
+    :break => lambda { |src, sexp|
+      src.emit("break")
+      src.emit(" ") unless sexp[1] == [:args_new]
+      src.resource(sexp[1])
+    },
+    :call => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(sexp[2])
+      src.resource(sexp[3])
+    },
+    :case => lambda { |src, sexp|
+      src.emit("case ")
+      src.resource(sexp[1])
+      src.emit(" ")
+      src.resource(sexp[2])
+      src.emit(" end")
+    },
+    :class => lambda { |src, sexp|
+      src.emit("class ")
+      src.resource(sexp[1])
+      if ! src.void?(sexp[2])
+        src.emit " < "
+        src.resource(sexp[2])
+      end
+      src.emit("; ")
+      src.resource(sexp[3]) unless src.void?(sexp[3])
+      src.emit("end")
+    },
+    :class_name_error => NYI,
+    :command => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" ")
+      src.resource(sexp[2])
+    },
+    :command_call => NYI,
+    :const_path_field => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit("::")
+      src.resource(sexp[2])
+    },
+    :const_path_ref => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit("::")
+      src.resource(sexp[2])
+    },
+    :const_ref => PASS1,
+    :def => lambda { |src, sexp|
+      src.emit("def ")
+      src.resource(sexp[1])
+      src.opt_parens(sexp[2])
+      src.resource(sexp[3])
+      src.emit("end")
+    },
+    :defined => lambda { |src, sexp|
+      src.emit("defined?(")
+      src.resource(sexp[1])
+      src.emit(")")
+    },
+    :defs => NYI,
+    :do_block => lambda { |src, sexp|
+      src.emit(" do")
+      src.handle_block(sexp)
+      src.emit("end")
+    },
+    :dot2 => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit("..")
+      src.resource(sexp[2])
+    },
+    :dot3 => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit("...")
+      src.resource(sexp[2])
+    },
+    :dyna_symbol => lambda { |src, sexp|
+      src.emit(':"')
+      src.resource(sexp[1])
+      src.emit('"')
+    },
+    :else => lambda { |src, sexp|
+      src.emit(" else ")
+      src.resource(sexp[1])
+    },
+    :elsif => lambda { |src, sexp|
+      src.emit(" elsif ")
+      src.resource(sexp[1])
+      src.emit(" then ")
+      src.resource(sexp[2])
+      src.resource(sexp[3])
+    },
+    :ensure => lambda { |src, sexp|
+      src.emit("ensure ")
+      if sexp[1]
+        src.resource(sexp[1])
+        src.emit("; ") unless src.void?(sexp[1])
+      end
+    },
+    :excessed_comma => NYI,
+    :fcall => PASS1,
+    :field => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(sexp[2])
+      src.resource(sexp[3])
+    },
+    :for => lambda { |src, sexp|
+      src.emit("for ")
+      src.resource(sexp[1])
+      src.emit(" in ")
+      src.resource(sexp[2])
+      src.emit(" do ")
+      unless src.void?(sexp[3])
+        src.resource(sexp[3])
+        src.emit(" ")
+      end
+      src.emit("end")
+    },
+    :hash => lambda { |src, sexp|
+      src.emit("{")
+      src.resource(sexp[1])
+      src.emit("}")
+    },
+    :if => lambda { |src, sexp|
+      src.emit("if ")
+      src.resource(sexp[1])
+      src.emit(" then ")
+      src.resource(sexp[2])
+      src.resource(sexp[3])
+      src.emit(" end")
+    },
+    :if_mod => lambda { |src, sexp|
+      src.resource(sexp[2])
+      src.emit(" if ")
+      src.resource(sexp[1])
+    },
+    :ifop => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" ? ")
+      src.resource(sexp[2])
+      src.emit(" : ")
+      src.resource(sexp[3])
+    },
+    :lambda => lambda { |src, sexp|
+      src.emit("->")
+      src.resource(sexp[1])
+      src.emit(" {")
+      if ! src.void?(sexp[2])
+        src.emit(" ")
+        src.resource(sexp[2])
+      end
+      src.emit(" ")
+      src.emit("}")
+    },
+    :magic_comment => NYI,
+    :massign => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" = ")
+      src.resource(sexp[2])
+    },
+    :method_add_arg => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.resource(sexp[2])
+    },
+    :method_add_block => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.resource(sexp[2])
+    },
+    :mlhs_add => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(", ") unless sexp[1] == [:mlhs_new]
+      src.resource(sexp[2])
+    },
+    :mlhs_add_star => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(", ") unless sexp[1] == [:mlhs_new]
+      src.emit("*")
+      src.resource(sexp[2])
+    },
+    :mlhs_new => NOOP,
+    :mlhs_paren => lambda { |src, sexp|
+      src.emit("(")
+      src.resource(sexp[1])
+      src.emit(")")
+    },
+    :module => lambda { |src, sexp|
+      src.emit("module ")
+      src.resource(sexp[1])
+      if src.void?(sexp[2])
+        src.emit("; ")
+      else
+        src.resource(sexp[2])
+      end
+      src.emit("end")
+    },
+    :mrhs_add => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(", ")
+      src.resource(sexp[2])
+    },
+    :mrhs_add_star => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(", ")
+      src.emit("*")
+      src.resource(sexp[2])
+    },
+    :mrhs_new => NYI,
+    :mrhs_new_from_args => PASS1,
+    :next => lambda { |src, sexp|
+      src.emit("next")
+    },
+    :opassign => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" ")
+      src.resource(sexp[2])
+      src.emit(" ")
+      src.resource(sexp[3])
+    },
+    :param_error => NYI,
+    :params => lambda { |src, sexp|
+      src.params(sexp[1], sexp[2], sexp[3], sexp[4], sexp[5])
+    },
+    :paren => lambda { |src, sexp|
+      src.emit("(")
+      src.resource(sexp[1])
+      src.emit(")")
+    },
+    :parse_error => NYI,
+    :program => PASS1,
+    :qwords_add => lambda { |src, sexp|
+      src.words("w", sexp)
+    },
+    :qwords_new => NOOP,
+    :redo => lambda { |src, sexp|
+      src.emit("redo")
+    },
+    :regexp_literal => lambda { |src, sexp|
+      src.emit("/")
+      src.resource(sexp[1])
+      src.emit("/")
+    },
+    :rescue => lambda { |src, sexp|
+      src.emit("rescue")
+      if sexp[1]                # Exception list
+        src.emit(" ")
+        if sexp[1].first.kind_of?(Symbol)
+          src.resource(sexp[1])
+        else
+          src.resource(sexp[1].first)
+        end
+        src.emit(" => ")
+        src.resource(sexp[2]) 
+      end
+      src.emit(";")
+      if sexp[3]                # Rescue Code
+        if src.void?(sexp[3])
+          src.emit(" ")
+        else
+          src.emit(" ")
+          src.resource(sexp[3])
+          src.emit("; ")
+        end
+      end
+    },
+    :rescue_mod => lambda { |src, sexp|
+      src.resource(sexp[2])
+      src.emit(" rescue ")
+      src.resource(sexp[1])
+    },
+    :rest_param => lambda { |src, sexp|
+      src.emit("*")
+      src.resource(sexp[1])
+    },
+    :retry => lambda { |src, sexp|
+      src.emit("retry")
+    },
+    :return => lambda { |src, sexp|
+      src.emit("return")
+      src.opt_parens(sexp[1])      
+    },
+    :return0 => lambda { |src, sexp|
+      src.emit("return")
+    },
+    :sclass => NYI,
+    :stmts_add => lambda { |src, sexp|
+      if sexp[1] != [:stmts_new]
+        src.resource(sexp[1])
+        src.emit("; ")
+      end
+      src.resource(sexp[2])
+    },
+    :stmts_new => NOOP,
+    :string_add => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.resource(sexp[2])
+    },
+    :string_concat => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.emit(" ")
+      src.resource(sexp[2])
+    },
+    :string_content => NOOP,
+    :string_dvar => NYI,
+    :string_embexpr => lambda { |src, sexp|
+      src.emit('#{')
+      src.resource(sexp[1])
+      src.emit('}')
+    },
+    :string_literal => lambda { |src, sexp|
+      src.emit('"')
+      src.resource(sexp[1])
+      src.emit('"')
+    },
+    :super => lambda { |src, sexp|
+      src.emit("super")
+      src.opt_parens(sexp[1])
+    },
+    :symbol => lambda { |src, sexp|
+      src.emit(":")
+      src.resource(sexp[1])
+    },
+    :symbol_literal => PASS1,
+    :top_const_field => NYI,
+    :top_const_ref => NYI,
+    :unary => lambda { |src, sexp|
+      src.emit(sexp[1].to_s[0,1])
+      src.resource(sexp[2])
+    },
+    :undef => lambda { |src, sexp|
+      src.emit("undef ")
+      src.resource(sexp[1].first)
+    },
+    :unless => lambda { |src, sexp|
+      src.emit("unless ")
+      src.resource(sexp[1])
+      src.emit(" then ")
+      src.resource(sexp[2])
+      src.resource(sexp[3])
+      src.emit(" end")
+    },
+    :unless_mod => lambda { |src, sexp|
+      src.resource(sexp[2])
+      src.emit(" unless ")
+      src.resource(sexp[1])
+    },
+    :until => lambda { |src, sexp|
+      src.emit("until ")
+      src.resource(sexp[1])
+      src.emit(" do ")
+      src.resource(sexp[2])
+      src.emit(" end")
+    },
+    :until_mod => lambda { |src, sexp|
+      src.resource(sexp[2])
+      src.emit(" until ")
+      src.resource(sexp[1])
+    },
+    :var_alias => NYI,
+    :var_field => PASS1,
+    :var_ref => PASS1,
+    :void_stmt => NOOP,
+    :when => lambda { |src, sexp|
+      src.emit("when ")
+      src.resource(sexp[1])
+      src.emit("; ")
+      src.resource(sexp[2])
+      if sexp[3] && sexp[3].first == :when
+        src.emit(" ")
+      end
+      src.resource(sexp[3])      
+    },
+    :while => lambda { |src, sexp|
+      src.emit("while ")
+      src.resource(sexp[1])
+      src.emit(" do ")
+      src.resource(sexp[2])
+      src.emit(" end")
+    },
+    :while_mod => lambda { |src, sexp|
+      src.resource(sexp[2])
+      src.emit(" while ")
+      src.resource(sexp[1])
+    },
+    :word_add => PASS2,
+    :word_new => NOOP,
+    :words_add => lambda { |src, sexp|
+      src.words("W", sexp)
+    },
+    :words_new => NOOP,
+    :xstring_add => lambda { |src, sexp|
+      src.resource(sexp[1])
+      src.resource(sexp[2])
+    },
+    :xstring_literal => lambda { |src, sexp|
+      src.emit('"')
+      src.resource(sexp[1])
+      src.emit('"')
+    },
+    :xstring_new => NOOP,
+    :yield => lambda { |src, sexp|
+      src.emit("yield")
+      src.opt_parens(sexp[1])
+    },
+    :yield0 => lambda { |src, sexp|
+      src.emit("yield")
+    },
+    :zsuper => lambda { |src, sexp|
+      src.emit("super")
+    },
+
+    # Scanner keywords
+
+    :@CHAR => NYI,
+    :@__end__ => NYI,
+    :@backref => NYI,
+    :@backtick => NYI,
+    :@comma => NYI,
+    :@comment => NYI,
+    :@const => EMIT1,
+    :@cvar => EMIT1,
+    :@embdoc => NYI,
+    :@embdoc_beg => NYI,
+    :@embdoc_end => NYI,
+    :@embexpr_beg => NYI,
+    :@embexpr_end => NYI,
+    :@embvar => NYI,
+    :@float => EMIT1,
+    :@gvar => EMIT1,
+    :@heredoc_beg => NYI,
+    :@heredoc_end => NYI,
+    :@ident => EMIT1,
+    :@ignored_nl => NYI,
+    :@int => EMIT1,
+    :@ivar => EMIT1,
+    :@kw => EMIT1,
+    :@label => NYI,
+    :@lbrace => NYI,
+    :@lbracket => NYI,
+    :@lparen => NYI,
+    :@nl => NYI,
+    :@op => EMIT1,
+    :@period => NYI,
+    :@qwords_beg => NYI,
+    :@rbrace => NYI,
+    :@rbracket => NYI,
+    :@regexp_beg => NYI,
+    :@regexp_end => NYI,
+    :@rparen => NYI,
+    :@semicolon => NYI,
+    :@sp => NYI,
+    :@symbeg  => NYI,
+    :@tlambda => NYI,
+    :@tlambeg => NYI,
+    :@tstring_beg => NYI,
+    :@tstring_content => EMIT1,
+    :@tstring_end => NYI,
+    :@words_beg => NYI,
+    :@words_sep => NYI,
+  }
+end
+

data/test/sorcerer/sorcerer_test.rb

@@ -0,0 +1,521 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'ripper'
+require 'sorcerer'
+
+class SourcerTest < Test::Unit::TestCase
+  def source(string, debug=false)
+    if debug
+      puts
+      puts "************************************************************"
+    end
+    sexp = Ripper::SexpBuilder.new(string).parse
+    Sorcerer.source(sexp, debug)
+  end
+
+  def test_can_source_variables
+    assert_resource "a"
+    assert_resource "b"
+  end
+
+  def test_can_source_constants
+    assert_resource "A"
+    assert_resource "Mod::X"
+    assert_resource "Mod::NS::Y"
+  end
+
+  def test_can_source_constant_definition
+    assert_resource "X = 1"
+    assert_resource "X::Y = 1"
+    assert_resource "X::Y::Z = 1"
+  end
+
+  def test_can_source_instance_variables
+    assert_resource "@iv"
+  end
+
+  def test_can_source_class_instance_variables
+   assert_resource "@@iv"
+  end
+
+  def test_can_source_globals
+   assert_resource "$g"
+  end
+
+  def test_can_source_method_call_without_args
+    assert_resource "obj.meth"
+    assert_resource "obj.meth()"
+  end
+
+  def test_can_source_method_call_with_args 
+    assert_resource "obj.meth(a)"
+    assert_resource "obj.meth(a, b)"
+    assert_resource "obj.meth(a, b, c)"
+  end
+
+  def test_can_source_method_call_with_star_args
+    assert_resource "obj.meth(*args)"
+    assert_resource "obj.meth(a, *args)"
+  end
+
+  def test_can_source_method_call_with_block_args
+    assert_resource "obj.meth(&code)"
+    assert_resource "obj.meth(a, &code)"
+    assert_resource "obj.meth(a, *args, &code)"
+  end
+
+  def test_can_source_method_without_explicit_target
+    assert_resource "meth(a)"
+    assert_resource "meth(a, b)"
+    assert_resource "meth(a, b, c)"
+    assert_resource "meth(*args)"
+    assert_resource "meth(a, *args)"
+    assert_resource "meth(&code)"
+    assert_resource "meth(a, &code)"
+    assert_resource "meth(a, *args, &code)"
+  end
+
+  def test_can_source_method_without_explicit_poetry_mode
+    assert_resource "meth a"
+    assert_resource "meth a, b"
+    assert_resource "meth a, b, c"
+    assert_resource "meth *args"
+    assert_resource "meth a, *args"
+    assert_resource "meth &code"
+    assert_resource "meth a, &code"
+    assert_resource "meth a, *args, &code"
+    assert_resource "meth a, *args do |x| x.y end"
+  end
+
+  def test_can_source_method_with_bare_assoc
+    assert_resource "meth(:x => 1)"
+    assert_resource "meth(:x => 1, :y => 2)"
+    assert_resource "meth(a, :x => 1)"
+    assert_resource "meth(a, :x => 1, :y => 2)"
+  end
+
+  def test_can_source_method_with_do_block
+    assert_resource "meth do end"
+    assert_resource "meth do |a| end" 
+    assert_resource "meth(x, y, *rest, &code) do |a, b=1, c=x, *args, &block| one; two; three end"
+  end
+
+  def test_can_source_method_with_block
+    assert_resource "meth { }"
+    assert_resource "meth { |a| }" 
+    assert_resource "meth { |a, b| }"
+    assert_resource "meth { |*args| }"
+    assert_resource "meth { |a, *args| }"
+    assert_resource "meth { |&block| }"
+    assert_resource "meth { |*args, &block| }"
+    assert_resource "meth { |a, b, *args, &block| }"
+    assert_resource "meth { |a, b=1, *args, &block| }"
+    assert_resource "meth { |a, b=1, c=x, *args, &block| }"
+  end
+
+  def test_can_source_method_with_block_contents
+    assert_resource "meth { |a| a.x }"
+    assert_resource "meth { |a| a.x; b.z }"
+  end
+
+  def test_can_source_method_with_complex_args_and_block
+    assert_resource "meth(x, y, *rest, &code) { |a, b=1, c=x, *args, &block| one; two; three }"
+  end
+
+  def test_can_source_stabby_procs
+    assert_resource "->() { }"
+    assert_resource "->(a) { }"
+    assert_resource "->(a, b) { }"
+    assert_resource "->(a, *args) { }"
+    assert_resource "->(a, *args, &block) { }"
+    assert_resource "->(a) { b }"
+  end
+
+  def test_can_source_numbers
+    assert_resource "1"
+    assert_resource "3.14"
+  end
+
+  def test_can_source_strings
+    assert_resource '"HI"'
+    assert_equal '"HI"', source("'HI'")
+  end
+
+  def test_can_source_strings_with_escape_chars
+    assert_resource '"\n"'
+    assert_resource '"a\nb"'
+  end
+
+  def test_can_source_interpolated_strings
+    assert_resource '"my name is #{name}"'
+    assert_resource '"my name is #{x.a("B")}"'
+  end
+
+  def test_can_source_string_concat
+    assert_resource '"a" "b"'
+    assert_resource '"a" "b" "c"'
+    assert_resource '"a" "b" "c" "d"'
+  end
+
+  def test_can_source_qwords
+    assert_resource '%w{a}'
+    assert_resource '%w{a b}'
+    assert_resource '%w{a b c}'
+    assert_resource '%w{Now is the time for all good men}'
+  end
+
+  def test_can_source_words
+    assert_resource '%W{a}'
+    assert_resource '%W{a b}'
+    assert_resource '%W{a b c}'
+    assert_resource '%W{Now is the time for all good men}'
+  end
+  
+  def test_can_source_many_words
+    assert_resource '[%w{a b}, %w{c d}]'
+    assert_resource '[%W{a b}, %W{c d}]'
+  end
+  
+  def test_can_source_symbols
+    assert_resource ":sym"
+  end
+
+  def test_can_source_fancy_symbol_literals
+    assert_resource ':"hello, world"'
+  end
+
+  def test_can_source_regular_expressions
+    assert_resource "/a/"
+    assert_resource "/^a$/"
+    assert_resource "/a*/"
+    assert_resource "/.+/"
+    assert_resource "/\./"
+    assert_resource "/[a-z]/"
+    assert_resource "/\[a-z\]/"
+    assert_resource "/#{name}/"
+  end
+
+  def test_can_source_range
+    assert_resource "1..10"
+    assert_resource "1...10"
+  end
+
+  def test_can_source_array_literals
+    assert_resource "[]"
+    assert_resource "[1]"
+    assert_resource "[1]"
+    assert_resource "[1, 2]"
+    assert_resource "[one, 2, :three, \"four\"]"
+  end
+
+  def test_can_source_array_references
+    assert_resource "a[1]"
+    assert_resource "a.b[1, 4]"
+  end
+
+  def test_can_source_object_array_assignments
+    assert_resource "obj.a[a] = x"
+    assert_resource "obj.a[a, b] = x"
+  end
+
+  def test_can_source_hash_literals
+    assert_resource "{}"
+    assert_resource "{:a => 1}"
+    assert_resource "{:a => 1, :b => 2}"
+  end
+
+  def test_can_source_unary_expression
+    assert_resource "+1"
+    assert_resource "-1"
+    assert_resource "+a"
+    assert_resource "-a"
+  end
+
+  def test_can_source_binary_expressions
+    assert_resource "a + 1"
+    assert_resource "a + b"
+    assert_resource "a - b"
+    assert_resource "a * b"
+    assert_resource "a / b"
+    assert_resource "a && b"
+    assert_resource "a || b"
+  end
+
+  def test_can_source_trinary_expressions
+    assert_resource "a ? b : c"
+  end
+  
+  def test_can_source_complex_expressions
+    assert_resource "a + 1 * 3"
+    assert_resource "a + b"
+  end
+
+  def test_can_source_expressions_with_parenthesis
+    assert_resource "(a + 1) * 3"
+    assert_resource "(a + b) + c"
+    assert_resource "a + (b + c)"
+    assert_resource "((a))"
+  end
+
+  def test_can_source_assignment
+    assert_resource "a = b"
+  end
+
+  def test_can_source_object_assignment
+    assert_resource "obj.a = b"
+  end
+
+  def test_can_source_array_assignments
+    assert_resource "a[a] = x"
+    assert_resource "a[a, b] = x"
+  end
+
+  def test_can_source_operator_assignments
+    assert_resource "a += b"
+    assert_resource "a -= b"
+    assert_resource "a *= b"
+    assert_resource "a /= b"
+  end
+
+  def test_can_source_lambda
+    assert_resource "lambda { a }"
+    assert_resource "lambda { |x| a(x) }"
+  end
+
+  def test_can_source_defined
+    assert_resource "defined?(a)"
+  end
+
+  def test_can_source_undef
+    assert_resource "undef a"
+  end
+
+  def test_can_source_multiple_assignment
+    assert_resource "a, b, c = list"
+    assert_resource "a = x, y, z"
+    assert_resource "a, b, c = 1, 2, 3"
+    assert_resource "a, b, *c = 1, 2, 3, 4"
+    assert_resource "a, b, *c = 1, 2, *args"
+    assert_resource "(a, b), *c = 1, 2, *args"
+  end
+
+  def test_can_source_statement_sequences
+    assert_resource "a"
+    assert_resource "a; b"
+    assert_resource "a; b; c"
+  end
+
+  def test_can_source_begin_end
+    assert_resource "begin; end"
+    assert_resource "begin; a; end"
+    assert_resource "begin; a(); end"
+    assert_resource "begin; a; b; c; end"
+  end
+
+  def test_can_source_begin_rescue_end
+    assert_resource "begin; rescue; end"
+    assert_resource "begin; rescue E => ex; b; end"
+    assert_resource "begin; a; rescue E => ex; b; end"
+    assert_resource "begin; a; rescue E, F => ex; b; end"
+    assert_resource "begin; a; rescue E, F => ex; b; c; end"
+    assert_resource "begin; rescue E, F => ex; b; c; end"
+  end
+
+  def test_can_source_begin_ensure_end
+    assert_resource "begin; ensure end"
+    assert_resource "begin; ensure b; end"
+    assert_resource "begin; a; ensure b; end"
+    assert_resource "begin; a; ensure ; b; end"
+  end
+
+  def test_can_source_begin_rescue_ensure_end
+    assert_resource "begin; rescue; end"
+    assert_resource "begin; rescue E => ex; b; ensure c; end"
+    assert_resource "begin; a; rescue E => ex; b; ensure c; end"
+    assert_resource "begin; a; rescue E, F => ex; b; ensure c; end"
+    assert_resource "begin; a; rescue E, F => ex; b; c; ensure d; end"
+    assert_resource "begin; rescue E, F => ex; b; c; ensure d; end"
+  end
+
+  def test_can_source_rescue_modifier
+    assert_resource "a rescue b"
+  end
+
+  def test_can_source_if
+    assert_resource "if a then b end"
+  end
+
+  def test_can_source_if_else
+    assert_resource "if a then b else c end"
+  end
+
+  def test_can_source_if_elsif_else
+    assert_resource "if a then b elsif c then d else e end"
+  end
+
+  def test_can_source_if_elsif
+    assert_resource "if a then b elsif c then d end"
+  end
+
+  def test_can_source_unless
+    assert_resource "unless a then b end"
+  end
+
+  def test_can_source_unless_else
+    assert_resource "unless a then b else c end"
+  end
+
+  def test_can_source_while
+   assert_resource "while c do body end"
+  end
+
+  def test_can_source_until
+   assert_resource "until c do body end"
+  end
+
+  def test_can_source_for
+    assert_resource "for a in list do end"
+    assert_resource "for a in list do c end"
+  end
+
+  def test_can_source_break
+   assert_resource "while c do a; break if b; c end"
+   assert_resource "while c do a; break value if b; c end"
+  end
+
+  def test_can_source_next
+   assert_resource "while c do a; next if b; c end"
+  end
+
+  def test_can_source_case
+    assert_resource "case a when b; c end"
+    assert_resource "case a when b; c when d; e end"
+    assert_resource "case a when b; c when d; e else f end"
+  end
+
+  def test_can_source_if_modifier
+    assert_resource "a if b"
+  end
+
+  def test_can_source_unless_modifier
+    assert_resource "a unless b"
+  end
+
+  def test_can_source_while_modifier
+    assert_resource "a while b"
+  end
+
+  def test_can_source_until_modifier
+    assert_resource "a until b"
+  end
+
+  def test_can_source_alias
+    assert_resource "alias a b"
+  end
+
+  def test_can_source_fail
+    assert_resource "fail Err"
+    assert_resource "raise Err"
+  end
+
+  def test_can_source_retry
+    assert_resource "retry"
+  end
+  
+  def test_can_source_redo
+    assert_resource "redo"
+  end
+  
+  def test_can_source_return
+    assert_resource "return"
+    assert_resource "return value"
+  end
+  
+  def test_can_source_super
+    assert_resource "super"
+    assert_resource "super a"
+    assert_resource "super a, b"
+    assert_resource "super a, *args"
+    assert_resource "super a, *args, &block"
+    assert_resource "super()"
+    assert_resource "super(a)"
+    assert_resource "super(a, b)"
+    assert_resource "super(a, *args)"
+    assert_resource "super(a, *args, &block)"
+  end
+
+  def test_can_source_yield
+    assert_resource "yield"
+    assert_resource "yield a"
+    assert_resource "yield(a)"
+  end
+  
+  def test_can_source_self
+    assert_resource "self"
+  end
+
+  def test_can_source_def
+    assert_resource "def f a; end"
+    assert_resource "def f(); end"
+    assert_resource "def f(a); end"
+    assert_resource "def f(a, b); end"
+    assert_resource "def f(a, *args); end"
+    assert_resource "def f(a, *args, &block); end"
+    assert_resource "def f(a); x; end"
+    assert_resource "def f(a); x; y; end"
+  end
+
+  def test_can_source_class
+    assert_resource "class X; end"
+    assert_resource "class X; x; end"
+    assert_resource "class X; def f(); end; end"
+  end
+
+  def test_can_source_class_with_parent
+    assert_resource "class X < Y; end"
+    assert_resource "class X < Y; x; end"
+  end
+
+  def test_can_source_class_with_self_parent
+    assert_resource "class X < self; end"
+  end
+
+  def test_can_source_private_etc_in_class
+    assert_resource "class X; public; def f(); end; end"
+    assert_resource "class X; protected; def f(); end; end"
+    assert_resource "class X; private; def f(); end; end"
+    assert_resource "class X; def f(); end; public :f; end"
+    assert_resource "class X; def f(); end; protected :f; end"
+    assert_resource "class X; def f(); end; private :f; end"
+  end
+
+  def test_can_source_module
+    assert_resource "module X; end"
+    assert_resource "module X; x; end"
+    assert_resource "module X; def f(); end; end"
+  end
+
+  def test_can_source_BEGIN
+    assert_resource "BEGIN { }"
+    assert_resource "BEGIN { x }"
+    assert_resource "BEGIN { x; y }"
+  end
+
+  def test_can_source_END
+    assert_resource "END { }"
+    assert_resource "END { x }"
+    assert_resource "END { x; y }"
+  end
+
+  def test_can_source_then
+    assert_resource "Then { a == b }"
+  end
+
+  private
+
+  def assert_resource(string, debug=nil)
+    assert_equal string, source(string, debug)
+  end
+  
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: sorcerer
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jim Weirich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-25 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: "      Generate the original Ruby source from a Ripper-style abstract syntax tree.\n"
+email: jim.weirich@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.textile
+- Rakefile
+- lib/sorcerer/sorcerer.rb
+- lib/sorcerer.rb
+- test/sorcerer/sorcerer_test.rb
+has_rdoc: true
+homepage: http://github.com/jimweirich/sorcerer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.rdoc
+- --title
+- Rake -- Ruby Make
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Generate Source from Ripper ASTs
+test_files: []
+