sorcerer 0.0.7 → 0.1.0

data/README.textile

@@ -44,3 +44,58 @@ Ripper may be used to produce the s-expressions used by Sorcerer.  The following
   puts Sorcerer.source(sexp)
 </pre>
 
+h2. Options
+
+h3. Multi-Line Output
+
+If you want multi-line output of source, add the multiline option to
+the source command. 
+
+For example, given:
+
+<pre style="background: LightGrey">
+  sexp = Ripper::SexpBuilder.new("def foo; end").parse
+</pre>
+
+Then the following
+
+<pre style="background: LightGrey">
+  puts Sorcerer.source(sexp)
+</pre>
+
+generates single line output (the default):
+
+<pre style="background: LightBlue">
+def foo; end
+</pre>
+
+And the following
+
+<pre style="background: LightGrey">
+  puts Sorcerer.source(sexp, multiline: true)
+</pre>
+
+generates multi-line output
+
+<pre style="background: LightBlue">
+def foo
+end
+</pre>
+
+h3. Debugging Output
+
+If you wish to see the S-Expressions processed by Sorcerer and the
+output emitted, then use the debug option:
+
+<pre style="background: LightGrey">
+  puts Sorcerer.source(sexp, debug: true)
+</pre>
+
+h2. History
+
+* 0.0.7 - Basic single line version
+* 0.1.0 - Added support for multi-line output. Improved rendering of a
+   number of constructs
+
+
+

data/Rakefile

@@ -2,13 +2,13 @@
 
 require 'rake/clean'
 require 'rake/testtask'
-require 'rake/rdoctask'
+#require 'rdoc/task'
 
 require './lib/sorcerer/version'
 
 begin
   require 'rubygems'
-  require 'rake/gempackagetask'
+  require 'rubygems/package_task'
 rescue Exception
   nil
 end
@@ -25,7 +25,7 @@ PKG_FILES = FileList[
   'lib/**/*.rb',
   'test/**/*.rb',
 ]
-  
+
 BASE_RDOC_OPTIONS = [
   '--line-numbers', '--inline-source',
   '--main' , 'README.textile',
@@ -34,16 +34,17 @@ BASE_RDOC_OPTIONS = [
 
 task :default => :test
 
-rd = Rake::RDocTask.new("rdoc") do |rdoc|
-  rdoc.rdoc_dir = 'html'
-  rdoc.template = 'doc/jamis.rb'
-  rdoc.title    = "Sorcerer -- Its Like Magic"
-  rdoc.options = BASE_RDOC_OPTIONS.dup
-  rdoc.options << '-SHN' << '-f' << 'darkfish' if defined?(DARKFISH_ENABLED) && DARKFISH_ENABLED
-    
-  rdoc.rdoc_files.include('README.textile')
-  rdoc.rdoc_files.include('lib/**/*.rb', 'doc/**/*.rdoc')
-  rdoc.rdoc_files.exclude(/\bcontrib\b/)
+RDOC_FILES = FileList['lib/**/*.rb', 'doc/**/*.rdoc'].exclude(/\bcontrib\b/)
+
+if defined?(Rake::RDocTesk)
+  rd = Rake::RDocTask.new("rdoc") do |rdoc|
+    rdoc.rdoc_dir = 'html'
+    rdoc.template = 'doc/jamis.rb'
+    rdoc.title    = "Sorcerer -- Its Like Magic"
+    rdoc.options = BASE_RDOC_OPTIONS.dup
+    rdoc.options << '-SHN' << '-f' << 'darkfish' if defined?(DARKFISH_ENABLED) && DARKFISH_ENABLED
+    rdoc.rdoc_files = RDOC_FILES
+  end
 end
 
 if ! defined?(Gem)
@@ -53,13 +54,11 @@ else
     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.description = "Generate the original Ruby source from a Ripper-style abstract syntax tree."
+    s.files = PKG_FILES
     s.require_path = 'lib'                         # Use these for libraries.
     s.has_rdoc = true
-    s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+    s.extra_rdoc_files = RDOC_FILES.reject { |fn| fn =~ /\.rb$/ }.to_a
     s.rdoc_options = BASE_RDOC_OPTIONS
     s.author = "Jim Weirich"
     s.email = "jim.weirich@gmail.com"
@@ -67,7 +66,7 @@ else
     s.homepage = "http://github.com/jimweirich/sorcerer"
   end
 
-  package_task = Rake::GemPackageTask.new(SPEC) do |pkg|
+  package_task = Gem::PackageTask.new(SPEC) do |pkg|
     pkg.need_zip = true
     pkg.need_tar = true
   end

data/lib/sorcerer.rb

@@ -1,7 +1,7 @@
 module Sorcerer
   # Generate the source code for teh given Ripper S-Expression.
-  def self.source(sexp, debug=false)
-    Sorcerer::Resource.new(sexp, debug).source
+  def self.source(sexp, options={})
+    Sorcerer::Resource.new(sexp, options).source
   end
 
   # Generate a list of interesting subexpressions for sexp.

data/lib/sorcerer/resource.rb

@@ -2,62 +2,104 @@
 
 require 'ripper'
 
-module Sorcerer 
+module Sorcerer
   class Resource
-    class NoHandlerError < StandardError
+    class SorcererError < StandardError
     end
-    
-    def initialize(sexp, debug=false)
+
+    class NoHandlerError < SorcererError
+    end
+
+    class NotSexpError < SorcererError
+    end
+
+    class UnexpectedSexpError < SorcererError
+    end
+
+    def initialize(sexp, options={})
       @sexp = sexp
       @source = ''
-      @debug = debug
+      @debug = options[:debug]
+      @multiline = options[:multiline]
       @word_level = 0
+      @stack = []
     end
-    
+
     def source
+      @stack.clear
       resource(@sexp)
       @source
     end
-    
+
+    def sexp?(obj)
+      obj && obj.respond_to?(:each) && obj.first.is_a?(Symbol)
+    end
+
+    def nested_sexp?(obj)
+      obj && obj.respond_to?(:first) && sexp?(obj.first)
+    end
+
     def resource(sexp)
-      return unless sexp
+      sexp = sexp.first if nested_sexp?(sexp)
+      fail NotSexpError, "Not an S-EXPER: #{sexp.inspect}" unless sexp?(sexp)
       handler = HANDLERS[sexp.first]
       raise NoHandlerError.new(sexp.first) unless handler
       if @debug
         puts "----------------------------------------------------------"
         pp sexp
       end
+      @stack.push(sexp.first)
       handler.call(self, sexp)
+      @stack.pop
     end
-    
-    def handle_block(sexp)
-      resource(sexp[1])     # Arguments
+
+    def emit_block(sexp, do_word, end_word)
+      emit(" ")
+      emit(do_word)
+      resource(sexp[1]) if sexp[1] # Arguments
       if ! void?(sexp[2])
+        soft_newline
+        resource(sexp[2])       # Statements
+      end
+      if !void?(sexp[2])
+        soft_newline
+      else
         emit(" ")
-        resource(sexp[2])     # Statements
       end
-      emit(" ")
+      emit(end_word)
+    end
+
+    def params_have_parens?(sexp)
+      sexp.first == :arg_paren || sexp.first == :paren
     end
-    
+
+    def params_are_empty?(sexp)
+      params = sexp
+      params = sexp[1] if sexp.first == :paren || sexp.first == :arg_paren
+      params[1].nil? || params[1].empty?
+    end
+
     def opt_parens(sexp)
-      emit(" ") unless sexp.first == :arg_paren || sexp.first == :paren
+      if !params_have_parens?(sexp) && ! params_are_empty?(sexp)
+        emit(" ")
+      end
       resource(sexp)
     end
-    
+
     def emit(string)
-      puts "EMITTING '#{string}'" if @debug
+      puts "EMITTING '#{string}' (#{last_handler})" if @debug
       @source << string.to_s
     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
@@ -83,7 +125,7 @@ module Sorcerer
         resource(block_arg)
       end
     end
-    
+
     def words(marker, sexp)
       emit("%#{marker}{") if @word_level == 0
       @word_level += 1
@@ -95,18 +137,62 @@ module Sorcerer
       @word_level -= 1
       emit("}") if @word_level == 0
     end
-    
+
     VOID_STATEMENT = [:stmts_add, [:stmts_new], [:void_stmt]]
+    VOID_STATEMENT2 = [:stmts_add, [:stmts_new]]
     VOID_BODY = [:body_stmt, VOID_STATEMENT, nil, nil, nil]
     VOID_BODY2 = [:bodystmt, VOID_STATEMENT, nil, nil, nil]
-    
+
     def void?(sexp)
       sexp.nil? ||
         sexp == VOID_STATEMENT ||
+        sexp == VOID_STATEMENT2 ||
         sexp == VOID_BODY ||
         sexp == VOID_BODY2
     end
-    
+
+    def multiline?
+      @multiline
+    end
+
+    def last_handler
+      @stack.last
+    end
+
+    def newline
+      if multiline?
+        emit("\n")
+      else
+        emit("; ")
+      end
+    end
+
+    def soft_newline
+      if multiline?
+        emit("\n")
+      else
+        emit(" ")
+      end
+    end
+
+    BALANCED_DELIMS = {
+      '}' => '{',
+      ')' => '(',
+      '>' => '<',
+      ']' => '[',
+    }
+
+    def self.determine_regexp_delimiters(sexp)
+      sym, end_delim, other = sexp
+      fail UnexpectedSexpError, "Expected :@regexp_end, got #{sym.inspect}" unless sym == :@regexp_end
+      end_delim_char = end_delim[0]
+      first_delim = BALANCED_DELIMS[end_delim_char] || end_delim_char
+      if first_delim != '/'
+        first_delim = "%r#{first_delim}"
+      end
+      [first_delim, end_delim]
+    end
+
     NYI = lambda { |src, sexp| src.nyi(sexp) }
     DBG = lambda { |src, sexp| pp(sexp) }
     NOOP = lambda { |src, sexp| }
@@ -114,25 +200,31 @@ module Sorcerer
     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(" ")
+        if src.void?(sexp[1])
+          src.emit " }"
+        else
+          src.soft_newline
           src.resource(sexp[1])
+          src.soft_newline
+          src.emit("}")
         end
-        src.emit(" }")
       },
       :END => lambda { |src, sexp|
         src.emit("END {")
-        unless src.void?(sexp[1])
-          src.emit(" ")
+        if src.void?(sexp[1])
+          src.emit(" }")
+        else
+          src.soft_newline
           src.resource(sexp[1])
+          src.soft_newline
+          src.emit("}")
         end
-        src.emit(" }")
       },
       :alias => lambda { |src, sexp|
         src.emit("alias ")
@@ -190,7 +282,7 @@ module Sorcerer
       :args_prepend => NYI,
       :array => lambda { |src, sexp|
         src.emit("[")
-        src.resource(sexp[1])
+        src.resource(sexp[1]) if sexp[1]
         src.emit("]")
       },
       :assign => lambda { |src, sexp|
@@ -214,7 +306,7 @@ module Sorcerer
       },
       :bare_assoc_hash => lambda { |src, sexp|
         first = true
-        sexp[1].each do |sx|      
+        sexp[1].each do |sx|
           src.emit(", ") unless first
           first = false
           src.resource(sx)
@@ -222,7 +314,12 @@ module Sorcerer
       },
       :begin => lambda { |src, sexp|
         src.emit("begin")
-        src.resource(sexp[1])
+        if src.void?(sexp[1])
+          src.emit(" ")
+        else
+          src.soft_newline
+          src.resource(sexp[1])
+        end
         src.emit("end")
       },
       :binary => lambda { |src, sexp|
@@ -243,14 +340,12 @@ module Sorcerer
       },
       :body_stmt => lambda { |src, sexp|
         src.resource(sexp[1])     # Main Body
-        src.emit("; ")
-        src.resource(sexp[2])   # Rescue
-        src.resource(sexp[4])   # Ensure
+        src.newline unless src.void?(sexp[1])
+        src.resource(sexp[2]) if sexp[2]  # Rescue
+        src.resource(sexp[4]) if sexp[4]  # Ensure
       },
       :brace_block => lambda { |src, sexp|
-        src.emit(" {")
-        src.handle_block(sexp)
-        src.emit("}")
+        src.emit_block(sexp, "{", "}")
       },
       :break => lambda { |src, sexp|
         src.emit("break")
@@ -265,9 +360,10 @@ module Sorcerer
       :case => lambda { |src, sexp|
         src.emit("case ")
         src.resource(sexp[1])
-        src.emit(" ")
+        src.soft_newline
         src.resource(sexp[2])
-        src.emit(" end")
+        src.newline
+        src.emit("end")
       },
       :class => lambda { |src, sexp|
         src.emit("class ")
@@ -276,7 +372,7 @@ module Sorcerer
           src.emit " < "
           src.resource(sexp[2])
         end
-        src.emit("; ")
+        src.newline
         src.resource(sexp[3]) unless src.void?(sexp[3])
         src.emit("end")
       },
@@ -302,6 +398,7 @@ module Sorcerer
         src.emit("def ")
         src.resource(sexp[1])
         src.opt_parens(sexp[2])
+        src.newline
         src.resource(sexp[3])
         src.emit("end")
       },
@@ -312,9 +409,7 @@ module Sorcerer
       },
       :defs => NYI,
       :do_block => lambda { |src, sexp|
-        src.emit(" do")
-        src.handle_block(sexp)
-        src.emit("end")
+        src.emit_block(sexp, "do", "end")
       },
       :dot2 => lambda { |src, sexp|
         src.resource(sexp[1])
@@ -332,21 +427,31 @@ module Sorcerer
         src.emit('"')
       },
       :else => lambda { |src, sexp|
-        src.emit(" else ")
+        src.soft_newline
+        src.emit("else")
+        src.soft_newline
         src.resource(sexp[1])
       },
       :elsif => lambda { |src, sexp|
-        src.emit(" elsif ")
+        src.soft_newline
+        src.emit("elsif ")
         src.resource(sexp[1])
-        src.emit(" then ")
+        if src.multiline?
+          src.soft_newline
+        else
+          src.emit(" then ")
+        end
         src.resource(sexp[2])
-        src.resource(sexp[3])
+        src.resource(sexp[3]) if sexp[3]
       },
       :ensure => lambda { |src, sexp|
-        src.emit("ensure ")
-        if sexp[1]
+        src.emit("ensure")
+        if src.void?(sexp[1])
+          src.soft_newline
+        else
+          src.soft_newline
           src.resource(sexp[1])
-          src.emit("; ") unless src.void?(sexp[1])
+          src.newline unless src.void?(sexp[1])
         end
       },
       :excessed_comma => NYI,
@@ -370,16 +475,21 @@ module Sorcerer
       },
       :hash => lambda { |src, sexp|
         src.emit("{")
-        src.resource(sexp[1])
+        src.resource(sexp[1]) if sexp[1]
         src.emit("}")
       },
       :if => lambda { |src, sexp|
         src.emit("if ")
         src.resource(sexp[1])
-        src.emit(" then ")
+        if src.multiline?
+          src.newline
+        else
+          src.emit(" then ")
+        end
         src.resource(sexp[2])
-        src.resource(sexp[3])
-        src.emit(" end")
+        src.resource(sexp[3]) if sexp[3]
+        src.soft_newline
+        src.emit("end")
       },
       :if_mod => lambda { |src, sexp|
         src.resource(sexp[2])
@@ -438,8 +548,8 @@ module Sorcerer
       :module => lambda { |src, sexp|
         src.emit("module ")
         src.resource(sexp[1])
+        src.newline
         if src.void?(sexp[2])
-          src.emit("; ")
         else
           src.resource(sexp[2])
         end
@@ -486,10 +596,12 @@ module Sorcerer
       :redo => lambda { |src, sexp|
         src.emit("redo")
       },
+      :regexp_add => PASS2,
       :regexp_literal => lambda { |src, sexp|
-        src.emit("/")
+        delims = determine_regexp_delimiters(sexp[2])
+        src.emit(delims[0])
         src.resource(sexp[1])
-        src.emit("/")
+        src.emit(delims[1])
       },
       :rescue => lambda { |src, sexp|
         src.emit("rescue")
@@ -501,17 +613,12 @@ module Sorcerer
             src.resource(sexp[1].first)
           end
           src.emit(" => ")
-          src.resource(sexp[2]) 
+          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
+        src.newline
+        if sexp[3] && ! src.void?(sexp[3])
+          src.resource(sexp[3])
+          src.newline
         end
       },
       :rescue_mod => lambda { |src, sexp|
@@ -528,18 +635,18 @@ module Sorcerer
       },
       :return => lambda { |src, sexp|
         src.emit("return")
-        src.opt_parens(sexp[1])      
+        src.opt_parens(sexp[1])
       },
       :return0 => lambda { |src, sexp|
         src.emit("return")
       },
       :sclass => NYI,
       :stmts_add => lambda { |src, sexp|
-        if sexp[1] != [:stmts_new]
+        if sexp[1] != [:stmts_new] && ! src.void?(sexp[1])
           src.resource(sexp[1])
-          src.emit("; ")
+          src.newline
         end
-        src.resource(sexp[2])
+        src.resource(sexp[2]) if sexp[2]
       },
       :stmts_new => NOOP,
       :string_add => lambda { |src, sexp|
@@ -585,10 +692,15 @@ module Sorcerer
       :unless => lambda { |src, sexp|
         src.emit("unless ")
         src.resource(sexp[1])
-        src.emit(" then ")
+        if src.multiline?
+          src.newline
+        else
+          src.emit(" then ")
+        end
         src.resource(sexp[2])
-        src.resource(sexp[3])
-        src.emit(" end")
+        src.resource(sexp[3]) if sexp[3]
+        src.soft_newline
+        src.emit("end")
       },
       :unless_mod => lambda { |src, sexp|
         src.resource(sexp[2])
@@ -614,19 +726,22 @@ module Sorcerer
       :when => lambda { |src, sexp|
         src.emit("when ")
         src.resource(sexp[1])
-        src.emit("; ")
+        src.newline
         src.resource(sexp[2])
         if sexp[3] && sexp[3].first == :when
           src.emit(" ")
         end
-        src.resource(sexp[3])      
+        src.resource(sexp[3]) if sexp[3]
       },
       :while => lambda { |src, sexp|
         src.emit("while ")
         src.resource(sexp[1])
-        src.emit(" do ")
-        src.resource(sexp[2])
-        src.emit(" end")
+        src.newline
+        unless src.void?(sexp[2])
+          src.resource(sexp[2])
+          src.newline
+        end
+        src.emit("end")
       },
       :while_mod => lambda { |src, sexp|
         src.resource(sexp[2])
@@ -659,9 +774,9 @@ module Sorcerer
       :zsuper => lambda { |src, sexp|
         src.emit("super")
       },
-      
+
       # Scanner keywords
-      
+
       :@CHAR => NYI,
       :@__end__ => NYI,
       :@backref => NYI,
@@ -711,5 +826,5 @@ module Sorcerer
     }
     HANDLERS[:bodystmt] = HANDLERS[:body_stmt]
   end
-  
+
 end

data/lib/sorcerer/version.rb

@@ -1,7 +1,7 @@
 module Sorcerer
   VERSION_MAJOR = 0
-  VERSION_MINOR = 0
-  VERSION_BUILD = 7
+  VERSION_MINOR = 1
+  VERSION_BUILD = 0
   VERSION_BETA  = 0
 
   VERSION_NUMBERS = [VERSION_MAJOR, VERSION_MINOR, VERSION_BUILD] +

data/test/sorcerer/resource_test.rb

@@ -5,13 +5,13 @@ require 'ripper'
 require 'sorcerer'
 
 class SourcerTest < Test::Unit::TestCase
-  def source(string, debug=false)
-    if debug
+  def source(string, options={})
+    if options[:debug]
       puts
-      puts "************************************************************"
+      puts "***************************** options: #{options.inspect}"
     end
     sexp = Ripper::SexpBuilder.new(string).parse
-    Sorcerer.source(sexp, debug)
+    Sorcerer.source(sexp, options)
   end
 
   def test_can_source_variables
@@ -48,7 +48,7 @@ class SourcerTest < Test::Unit::TestCase
     assert_resource "obj.meth()"
   end
 
-  def test_can_source_method_call_with_args 
+  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)"
@@ -85,7 +85,7 @@ class SourcerTest < Test::Unit::TestCase
     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"
+    assert_resource "meth a, *args do |x| x.y end",
   end
 
   def test_can_source_method_with_bare_assoc
@@ -96,14 +96,14 @@ class SourcerTest < Test::Unit::TestCase
   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"
+    assert_resource_ml "meth do end"
+    assert_resource_ml "meth do |a| end"
+    assert_resource_ml "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| }"
     assert_resource "meth { |a, b| }"
     assert_resource "meth { |*args| }"
     assert_resource "meth { |a, *args| }"
@@ -138,7 +138,7 @@ class SourcerTest < Test::Unit::TestCase
       assert_resource "p.(a)"
     end
   end
-  
+
   def test_can_source_numbers
     assert_resource "1"
     assert_resource "3.14"
@@ -178,12 +178,12 @@ class SourcerTest < Test::Unit::TestCase
     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
@@ -203,6 +203,19 @@ class SourcerTest < Test::Unit::TestCase
     assert_resource '/#{name}/'
   end
 
+  def test_can_source_regular_expressions_with_alternate_delimiters
+    assert_resource "%r{a}"
+    assert_resource "%r<a>"
+    assert_resource "%r[a]"
+    assert_resource "%r(a)"
+    assert_resource "%r|a|"
+  end
+
+  def test_can_source_regular_expressions_with_flags
+    assert_resource "%r{a}im"
+    assert_resource "/a/i"
+  end
+
   def test_can_source_range
     assert_resource "1..10"
     assert_resource "1...10"
@@ -252,7 +265,7 @@ class SourcerTest < Test::Unit::TestCase
   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"
@@ -308,41 +321,41 @@ class SourcerTest < Test::Unit::TestCase
   end
 
   def test_can_source_statement_sequences
-    assert_resource "a"
-    assert_resource "a; b"
-    assert_resource "a; b; c"
+    assert_resource_ml "a"
+    assert_resource_ml "a; b"
+    assert_resource_ml "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"
+    assert_resource_ml "begin end"
+    assert_resource_ml "begin~a; end"
+    assert_resource_ml "begin~a(); end"
+    assert_resource_ml "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"
+    assert_resource_ml "begin~rescue; end"
+    assert_resource_ml "begin~rescue E => ex; b; end"
+    assert_resource_ml "begin~a; rescue E => ex; b; end"
+    assert_resource_ml "begin~a; rescue E, F => ex; b; end"
+    assert_resource_ml "begin~a; rescue E, F => ex; b; c; end"
+    assert_resource_ml "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"
+    assert_resource_ml "begin~ensure~end"
+    assert_resource_ml "begin~ensure~b; end"
+    assert_resource_ml "begin~a; ensure~b; end"
+    assert_resource_ml "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"
+    assert_resource_ml "begin~rescue; end"
+    assert_resource_ml "begin~rescue E => ex; b; ensure~c; end"
+    assert_resource_ml "begin~a; rescue E => ex; b; ensure~c; end"
+    assert_resource_ml "begin~a; rescue E, F => ex; b; ensure~c; end"
+    assert_resource_ml "begin~a; rescue E, F => ex; b; c; ensure~d; end"
+    assert_resource_ml "begin~rescue E, F => ex; b; c; ensure~d; end"
   end
 
   def test_can_source_rescue_modifier
@@ -351,30 +364,37 @@ class SourcerTest < Test::Unit::TestCase
 
   def test_can_source_if
     assert_resource "if a then b end"
+    assert_resource "if a\nb\nend", multiline: true
   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"
+    assert_resource "if a\nb\nelse\nc\nend", multiline: true
   end
 
   def test_can_source_if_elsif
     assert_resource "if a then b elsif c then d end"
+    assert_resource "if a\nb\nelsif c\nd\nend", multiline: true
+  end
+
+  def test_can_source_if_elsif_else
+    assert_resource "if a then b elsif c then d else e end"
+    assert_resource "if a\nb\nelsif c\nd\nelse\ne\nend", multiline: true
   end
 
   def test_can_source_unless
     assert_resource "unless a then b end"
+    assert_resource "unless a\nb\nend", multiline: true
   end
 
   def test_can_source_unless_else
     assert_resource "unless a then b else c end"
+    assert_resource "unless a\nb\nelse\nc\nend", multiline: true
   end
 
   def test_can_source_while
-   assert_resource "while c do body end"
+    assert_resource_ml "while c; end"
+    assert_resource_ml "while c; body; end"
   end
 
   def test_can_source_until
@@ -387,18 +407,19 @@ class SourcerTest < Test::Unit::TestCase
   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"
+   assert_resource_ml "while c; a; break if b; c; end"
+   assert_resource_ml "while c; a; break value if b; c; end"
   end
 
   def test_can_source_next
-   assert_resource "while c do a; next if b; c end"
+   assert_resource_ml "while c; a; next if b; c; end"
+   assert_resource_ml "while c; 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"
+    assert_resource_ml "case a~when b; c; end"
+    assert_resource_ml "case a~when b; c when d; e; end"
+    assert_resource_ml "case a~when b; c when d; e~else~f; end"
   end
 
   def test_can_source_if_modifier
@@ -429,16 +450,16 @@ class SourcerTest < Test::Unit::TestCase
   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"
@@ -457,72 +478,93 @@ class SourcerTest < Test::Unit::TestCase
     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"
+    assert_resource_ml "def f; end"
+    assert_resource_ml "def f; x; end"
+    assert_resource_ml "def f a; end"
+    assert_resource_ml "def f(); end"
+    assert_resource_ml "def f(a); end"
+    assert_resource_ml "def f(a, b); end"
+    assert_resource_ml "def f(a, *args); end"
+    assert_resource_ml "def f(a, *args, &block); end"
+    assert_resource_ml "def f(a); x; end"
+    assert_resource_ml "def f(a); x; y; end"
   end
 
   def test_can_source_class_without_parent
-    assert_resource "class X; end"
-    assert_resource "class X; x; end"
-    assert_resource "class X; def f(); end; end"
+    assert_resource_ml "class X; end"
+    assert_resource_ml "class X; x; end"
+    assert_resource_ml "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"
+    assert_resource_ml "class X < Y; end"
+    assert_resource_ml "class X < Y; x; end"
   end
 
   def test_can_source_class_with_self_parent
-    assert_resource "class X < self; end"
+    assert_resource_ml "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"
+    assert_resource_ml "class X; public; def f(); end; end"
+    assert_resource_ml "class X; protected; def f(); end; end"
+    assert_resource_ml "class X; private; def f(); end; end"
+    assert_resource_ml "class X; def f(); end; public :f; end"
+    assert_resource_ml "class X; def f(); end; protected :f; end"
+    assert_resource_ml "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"
+    assert_resource_ml "module X; end"
+    assert_resource_ml "module X; x; end"
+    assert_resource_ml "module X; def f(); end; end"
   end
 
   def test_can_source_BEGIN
-    assert_resource "BEGIN { }"
-    assert_resource "BEGIN { x }"
-    assert_resource "BEGIN { x; y }"
+    assert_resource_ml "BEGIN { }"
+    assert_resource_ml "BEGIN {~x~}"
+    assert_resource_ml "BEGIN {~x; y~}"
   end
 
   def test_can_source_END
-    assert_resource "END { }"
-    assert_resource "END { x }"
-    assert_resource "END { x; y }"
+    assert_resource_ml "END { }"
+    assert_resource_ml "END {~x~}"
+    assert_resource_ml "END {~x; y~}"
   end
 
   def test_can_source_then
-    assert_resource "Then { a == b }"
+    assert_resource_ml "Then {~a == b~}"
+    assert_resource_ml "Then {~a == b; x~}"
+  end
+
+  def test_can_use_ripper_sexp_output
+    sexp = Ripper.sexp("a = 1")
+    assert_equal "a = 1", Sorcerer.source(sexp)
+  end
+
+  def test_can_handle_missing_statements
+    sexp = [:bodystmt, [:stmts_add, [:stmts_new]], nil, nil, nil]
+    assert_equal "", Sorcerer.source(sexp)
   end
 
   private
 
-  def assert_resource(string, debug=nil)
-    assert_equal string, source(string, debug)
+  def assert_resource(string, options={})
+    assert_equal string, source(string, options)
   end
-  
+
+  def assert_resource_ml(string, options={})
+    expected = string.gsub(/~/, " ")
+    assert_equal expected, source(expected, options)
+
+    expected_ml = string.gsub(/~/, "\n").gsub(/; /, "\n")
+    assert_equal expected_ml, source(expected_ml, {multiline: true}.merge(options))
+  end
+
 end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: sorcerer
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 7
-  version: 0.0.7
+  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors: 
 - Jim Weirich
@@ -14,18 +10,17 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-23 00:00:00 -04:00
-default_executable: 
+date: 2012-07-01 00:00:00 Z
 dependencies: []
 
-description: "      Generate the original Ruby source from a Ripper-style abstract syntax tree.\n"
+description: Generate the original Ruby source from a Ripper-style abstract syntax tree.
 email: jim.weirich@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- README.textile
+extra_rdoc_files: []
+
 files: 
 - README.textile
 - Rakefile
@@ -39,7 +34,6 @@ files:
 - lib/sorcerer.rb
 - test/sorcerer/resource_test.rb
 - test/sorcerer/subexpression_test.rb
-has_rdoc: true
 homepage: http://github.com/jimweirich/sorcerer
 licenses: []
 
@@ -54,23 +48,21 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: sorcerer
-rubygems_version: 1.3.6
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Generate Source from Ripper ASTs