sorcerer 0.2.0 → 0.3.0

data/README.textile

@@ -46,15 +46,14 @@ Ripper may be used to produce the s-expressions used by Sorcerer.  The following
 
 h2. Options
 
-h3. Multi-Line Output
+h3. No Options
 
-If you want multi-line output of source, add the multiline option to
-the source command. 
+By default, sorcerer will output its source in single line mode.
 
 For example, given:
 
 <pre style="background: LightGrey">
-  sexp = Ripper::SexpBuilder.new("def foo; end").parse
+  sexp = Ripper::SexpBuilder.new("def foo; bar; end").parse
 </pre>
 
 Then the following
@@ -66,10 +65,15 @@ Then the following
 generates single line output (the default):
 
 <pre style="background: LightBlue">
-def foo; end
+def foo; bar; end
 </pre>
 
-And the following
+h3. Multi-Line Output
+
+If you want multi-line output of source, add the multiline option to
+the source command.
+
+For example, given the sexp generated above, then this
 
 <pre style="background: LightGrey">
   puts Sorcerer.source(sexp, multiline: true)
@@ -79,6 +83,28 @@ generates multi-line output
 
 <pre style="background: LightBlue">
 def foo
+bar
+end
+</pre>
+
+(Note that all multi-line output will have a final newline.)
+
+h3. Indentation
+
+By default, sorcerer does not indent its multiline output.  Adding the
+"indent" option will cause the output to be indented.
+
+For example, given the sexp generated above, then the following
+
+<pre style="background: LightGrey">
+  puts Sorcerer.source(sexp, indent: true)
+</pre>
+
+generates indented output:
+
+<pre style="background: LightBlue">
+def foo
+  bar
 end
 </pre>
 
@@ -96,6 +122,6 @@ 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
-
+* 0.2.0 - Added support for indented output.
 
 

data/lib/sorcerer/resource.rb

@@ -33,6 +33,9 @@ module Sorcerer
     def source
       @stack.clear
       resource(@sexp)
+      if multiline?
+        @source << "\n" unless @source =~ /\n\z/m
+      end
       @source
     end
 
@@ -203,6 +206,10 @@ module Sorcerer
         sexp == VOID_BODY2
     end
 
+    def label?(sexp)
+      sexp?(sexp) && sexp.first == :@label
+    end
+
     def last_handler
       @stack.last
     end
@@ -350,7 +357,11 @@ module Sorcerer
       :assign_error => NYI,
       :assoc_new => lambda { |sexp|
         resource(sexp[1])
-        emit(" => ")
+        if label?(sexp[1])
+          emit(" ")
+        else
+          emit(" => ")
+        end
         resource(sexp[2])
       },
       :assoclist_from_args => lambda { |sexp|
@@ -536,8 +547,11 @@ module Sorcerer
       },
       :hash => lambda { |sexp|
         emit("{")
-        resource(sexp[1]) if sexp[1]
-        emit("}")
+        if sexp[1]
+          emit(" ")
+          resource(sexp[1])
+        end
+        emit(" }")
       },
       :if => lambda { |sexp|
         emit("if ")
@@ -862,7 +876,7 @@ module Sorcerer
       :@int => EMIT1,
       :@ivar => EMIT1,
       :@kw => EMIT1,
-      :@label => NYI,
+      :@label => EMIT1,
       :@lbrace => NYI,
       :@lbracket => NYI,
       :@lparen => NYI,

data/lib/sorcerer/version.rb

@@ -1,6 +1,6 @@
 module Sorcerer
   VERSION_MAJOR = 0
-  VERSION_MINOR = 2
+  VERSION_MINOR = 3
   VERSION_BUILD = 0
   VERSION_BETA  = 0
 

data/test/sorcerer/resource_test.rb

@@ -32,7 +32,7 @@ class SourcerTest < Test::Unit::TestCase
   # * "#" is expected to be a tabbed indent in indent mode and a null
   # string in single line and multi-line modes.
   #
-  def assert_resource_ml(string)
+  def assert_resource_lines(string)
     assert_resource_for_mode(string, multiline: false) { |s| for_single_line(s) }
     assert_resource_for_mode(string, multiline: true)  { |s| for_multi_line(s) }
     assert_resource_for_mode(string, indent: true)     { |s| for_indented(s) }
@@ -46,15 +46,26 @@ class SourcerTest < Test::Unit::TestCase
   end
 
   def for_single_line(string)
-    string.gsub(/~/, " ").gsub(/#/,'')
+    string.
+      gsub(/\bTHEN~/, "then ").
+      gsub(/~/, " ").
+      gsub(/#/,'')
   end
 
   def for_multi_line(string)
-    string.gsub(/~/, "\n").gsub(/; /, "\n").gsub(/#/,'')
+    string.
+      gsub(/\b THEN~/, "; ").
+      gsub(/~/, "\n").
+      gsub(/; /, "\n").
+      gsub(/#/,'') + "\n"
   end
 
   def for_indented(string)
-    string.gsub(/~/, "\n").gsub(/; /, "\n").gsub(/#/,'  ')
+    string.
+      gsub(/\b THEN~/, "; ").
+      gsub(/~/, "\n").
+      gsub(/; /, "\n").
+      gsub(/#/,'  ') + "\n"
   end
 
   def source(string, options={})
@@ -63,6 +74,7 @@ class SourcerTest < Test::Unit::TestCase
       puts "***************************** options: #{options.inspect}"
     end
     sexp = Ripper::SexpBuilder.new(string).parse
+    fail "Failed to parts '#{string}'" if sexp.nil?
     Sorcerer.source(sexp, options)
   end
 
@@ -149,42 +161,50 @@ class SourcerTest < Test::Unit::TestCase
     assert_resource "meth(a, :x => 1, :y => 2)"
   end
 
+  def test_can_source_method_with_new_hash_syntax
+    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)"
+    assert_resource "meth(a, :x => 1, y: 2)"
+  end
+
   def test_can_source_method_with_do_block
-    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"
+    assert_resource_lines "meth do end"
+    assert_resource_lines "meth do |a| end"
+    assert_resource_lines "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| }"
+    assert_resource_lines "meth { }"
+    assert_resource_lines "meth { |a| }"
+    assert_resource_lines "meth { |a, b| }"
+    assert_resource_lines "meth { |*args| }"
+    assert_resource_lines "meth { |a, *args| }"
+    assert_resource_lines "meth { |&block| }"
+    assert_resource_lines "meth { |*args, &block| }"
+    assert_resource_lines "meth { |a, b, *args, &block| }"
+    assert_resource_lines "meth { |a, b=1, *args, &block| }"
+    assert_resource_lines "meth { |a, b=1, c=x, *args, &block| }"
   end
 
   def test_can_source_method_with_block_contents
-    assert_resource_ml "meth { |a|~#a.x~}"
-    assert_resource_ml "meth { |a|~#a.x; #b.z~}"
+    assert_resource_lines "meth { |a|~#a.x~}"
+    assert_resource_lines "meth { |a|~#a.x; #b.z~}"
   end
 
   def test_can_source_method_with_complex_args_and_block
-    assert_resource_ml "meth(x, y, *rest, &code) { |a, b=1, c=x, *args, &block|~#one; #two; #three~}"
+    assert_resource_lines "meth(x, y, *rest, &code) { |a, b=1, c=x, *args, &block|~#one; #two; #three~}"
   end
 
   def test_can_source_stabby_procs
-    assert_resource_ml "-> { }"
-    assert_resource_ml "->() { }"
-    assert_resource_ml "->(a) { }"
-    assert_resource_ml "->(a, b) { }"
-    assert_resource_ml "->(a, *args) { }"
-    assert_resource_ml "->(a, b=12, *args, &block) { }"
-    assert_resource_ml "->(a) {~b~}"
+    assert_resource_lines "-> { }"
+    assert_resource_lines "->() { }"
+    assert_resource_lines "->(a) { }"
+    assert_resource_lines "->(a, b) { }"
+    assert_resource_lines "->(a, *args) { }"
+    assert_resource_lines "->(a, b=12, *args, &block) { }"
+    assert_resource_lines "->(a) {~b~}"
   end
 
   def test_can_source_dot_calls
@@ -295,9 +315,19 @@ class SourcerTest < Test::Unit::TestCase
   end
 
   def test_can_source_hash_literals
-    assert_resource "{}"
-    assert_resource "{:a => 1}"
-    assert_resource "{:a => 1, :b => 2}"
+    assert_resource "{ }"
+    assert_resource "{ :a => 1 }"
+    assert_resource "{ :a => 1, :b => 2 }"
+  end
+
+  def test_can_source_new_hash_literals
+    assert_resource "{ }"
+    assert_resource "{ a: 1 }"
+    assert_resource "{ a: 1, b: 2 }"
+  end
+
+  def test_can_source_mixed_hash_literals
+    assert_resource "{ a: 1, :b => 2, c: 3, :d => 4 }"
   end
 
   def test_can_source_unary_expression
@@ -376,41 +406,41 @@ class SourcerTest < Test::Unit::TestCase
   end
 
   def test_can_source_statement_sequences
-    assert_resource_ml "a"
-    assert_resource_ml "a; b"
-    assert_resource_ml "a; b; c"
+    assert_resource_lines "a"
+    assert_resource_lines "a; b"
+    assert_resource_lines "a; b; c"
   end
 
   def test_can_source_begin_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"
+    assert_resource_lines "begin end"
+    assert_resource_lines "begin~#a; end"
+    assert_resource_lines "begin~#a(); end"
+    assert_resource_lines "begin~#a; #b; #c; end"
   end
 
   def test_can_source_begin_rescue_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"
+    assert_resource_lines "begin~rescue; end"
+    assert_resource_lines "begin~rescue E => ex; #b; end"
+    assert_resource_lines "begin~#a; rescue E => ex; #b; end"
+    assert_resource_lines "begin~#a; rescue E, F => ex; #b; end"
+    assert_resource_lines "begin~#a; rescue E, F => ex; #b; #c; end"
+    assert_resource_lines "begin~rescue E, F => ex; #b; #c; end"
   end
 
   def test_can_source_begin_ensure_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"
+    assert_resource_lines "begin~ensure~end"
+    assert_resource_lines "begin~ensure~#b; end"
+    assert_resource_lines "begin~#a; ensure~#b; end"
+    assert_resource_lines "begin~#a; ensure~#b; end"
   end
 
   def test_can_source_begin_rescue_ensure_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"
+    assert_resource_lines "begin~rescue; end"
+    assert_resource_lines "begin~rescue E => ex; #b; ensure~#c; end"
+    assert_resource_lines "begin~#a; rescue E => ex; #b; ensure~#c; end"
+    assert_resource_lines "begin~#a; rescue E, F => ex; #b; ensure~#c; end"
+    assert_resource_lines "begin~#a; rescue E, F => ex; #b; #c; ensure~#d; end"
+    assert_resource_lines "begin~rescue E, F => ex; #b; #c; ensure~#d; end"
   end
 
   def test_can_source_rescue_modifier
@@ -418,69 +448,57 @@ class SourcerTest < Test::Unit::TestCase
   end
 
   def test_can_source_if
-    assert_resource "if a then b end"
-    assert_resource "if a\nb\nend", multiline: true
-    assert_resource "if a\n  b\nend", indent: 2
+    assert_resource_lines "if a THEN~#b~end"
   end
 
   def test_can_source_if_else
-    assert_resource "if a then b else c end"
-    assert_resource "if a\nb\nelse\nc\nend", multiline: true
-    assert_resource "if a\n  b\nelse\n  c\nend", indent: 2
+    assert_resource_lines "if a THEN~#b~else~#c~end"
   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
-    assert_resource "if a\n  b\nelsif c\n  d\nend", indent: 2
+    assert_resource_lines "if a THEN~#b~elsif c THEN~#d~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\nelsif c\nd\nelse\ne\nend", multiline: true
-    assert_resource "if a\n  b\nelsif c\n  d\nelse\n  e\nend", indent: 2
+    assert_resource_lines "if a THEN~#b~elsif c THEN~#d~else~#e~end"
   end
 
   def test_can_source_unless
-    assert_resource "unless a then b end"
-    assert_resource "unless a\nb\nend", multiline: true
-    assert_resource "unless a\n  b\nend", indent: 2
+    assert_resource_lines "unless a THEN~#b~end"
   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
-    assert_resource "unless a\n  b\nelse\n  c\nend", indent: 2
+    assert_resource_lines "unless a THEN~#b~else~#c~end"
   end
 
   def test_can_source_while
-    assert_resource_ml "while c; end"
-    assert_resource_ml "while c; #body; end"
+    assert_resource_lines "while c; end"
+    assert_resource_lines "while c; #body; end"
   end
 
   def test_can_source_until
-   assert_resource_ml "until c; #body end"
+   assert_resource_lines "until c; #body end"
   end
 
   def test_can_source_for
-    assert_resource_ml "for a in list; end"
-    assert_resource_ml "for a in list; #c~end"
+    assert_resource_lines "for a in list; end"
+    assert_resource_lines "for a in list; #c~end"
   end
 
   def test_can_source_break
-   assert_resource_ml "while c; #a; #break if b; #c; end"
-   assert_resource_ml "while c; #a; #break value if b; #c; end"
+   assert_resource_lines "while c; #a; #break if b; #c; end"
+   assert_resource_lines "while c; #a; #break value if b; #c; end"
   end
 
   def test_can_source_next
-   assert_resource_ml "while c; #a; #next if b; #c; end"
-   assert_resource_ml "while c; #a; #next if b; #c; end"
+   assert_resource_lines "while c; #a; #next if b; #c; end"
+   assert_resource_lines "while c; #a; #next if b; #c; end"
   end
 
   def test_can_source_case
-    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"
+    assert_resource_lines "case a~when b; #c; end"
+    assert_resource_lines "case a~when b; #c when d; #e; end"
+    assert_resource_lines "case a~when b; #c when d; #e~else~#f; end"
   end
 
   def test_can_source_if_modifier
@@ -545,63 +563,63 @@ class SourcerTest < Test::Unit::TestCase
   end
 
   def test_can_source_def
-    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"
+    assert_resource_lines "def f; end"
+    assert_resource_lines "def f; #x; end"
+    assert_resource_lines "def f a; end"
+    assert_resource_lines "def f(); end"
+    assert_resource_lines "def f(a); end"
+    assert_resource_lines "def f(a, b); end"
+    assert_resource_lines "def f(a, *args); end"
+    assert_resource_lines "def f(a, *args, &block); end"
+    assert_resource_lines "def f(a); #x; end"
+    assert_resource_lines "def f(a); #x; #y; end"
   end
 
   def test_can_source_class_without_parent
-    assert_resource_ml "class X; end"
-    assert_resource_ml "class X; #x; end"
-    assert_resource_ml "class X; #def f(); #end; end"
+    assert_resource_lines "class X; end"
+    assert_resource_lines "class X; #x; end"
+    assert_resource_lines "class X; #def f(); #end; end"
   end
 
   def test_can_source_class_with_parent
-    assert_resource_ml "class X < Y; end"
-    assert_resource_ml "class X < Y; #x; end"
+    assert_resource_lines "class X < Y; end"
+    assert_resource_lines "class X < Y; #x; end"
   end
 
   def test_can_source_class_with_self_parent
-    assert_resource_ml "class X < self; end"
+    assert_resource_lines "class X < self; end"
   end
 
   def test_can_source_private_etc_in_class
-    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"
+    assert_resource_lines "class X; #public; #def f(); #end; end"
+    assert_resource_lines "class X; #protected; #def f(); #end; end"
+    assert_resource_lines "class X; #private; #def f(); #end; end"
+    assert_resource_lines "class X; #def f(); #end; #public :f; end"
+    assert_resource_lines "class X; #def f(); #end; #protected :f; end"
+    assert_resource_lines "class X; #def f(); #end; #private :f; end"
   end
 
   def test_can_source_module
-    assert_resource_ml "module X; end"
-    assert_resource_ml "module X; #x; end"
-    assert_resource_ml "module X; #def f(); #end; end"
+    assert_resource_lines "module X; end"
+    assert_resource_lines "module X; #x; end"
+    assert_resource_lines "module X; #def f(); #end; end"
   end
 
   def test_can_source_BEGIN
-    assert_resource_ml "BEGIN { }"
-    assert_resource_ml "BEGIN {~#x~}"
-    assert_resource_ml "BEGIN {~#x; #y~}"
+    assert_resource_lines "BEGIN { }"
+    assert_resource_lines "BEGIN {~#x~}"
+    assert_resource_lines "BEGIN {~#x; #y~}"
   end
 
   def test_can_source_END
-    assert_resource_ml "END { }"
-    assert_resource_ml "END {~#x~}"
-    assert_resource_ml "END {~#x; #y~}"
+    assert_resource_lines "END { }"
+    assert_resource_lines "END {~#x~}"
+    assert_resource_lines "END {~#x; #y~}"
   end
 
   def test_can_source_then
-    assert_resource_ml "Then {~#a == b~}"
-    assert_resource_ml "Then {~#a == b; #x~}"
+    assert_resource_lines "Then {~#a == b~}"
+    assert_resource_lines "Then {~#a == b; #x~}"
   end
 
   def test_can_use_ripper_sexp_output

data/test/sorcerer/subexpression_test.rb

@@ -20,7 +20,7 @@ class SubexpressionTest < Test::Unit::TestCase
 
   def test_unary_expressions
     assert_subexpressions "-(a+b)", [
-      "-(a + b)", "a + b", "a", "b", 
+      "-(a + b)", "a + b", "a", "b",
     ]
   end
 
@@ -61,8 +61,8 @@ class SubexpressionTest < Test::Unit::TestCase
   end
 
   def test_hash_literal
-    assert_subexpressions "{:a => aa, :b => bb}", [
-      "{:a => aa, :b => bb}", "aa", "bb"
+    assert_subexpressions "{ :a => aa, :b => bb }", [
+      "{ :a => aa, :b => bb }", "aa", "bb"
     ]
   end
 
@@ -74,7 +74,7 @@ class SubexpressionTest < Test::Unit::TestCase
     assert_subexpressions "o.f(a+b, c*d, x.y, z(k, 2, 3)) { xx }", [
       "o.f(a + b, c * d, x.y, z(k, 2, 3)) { xx }",
       "a + b", "a", "b",
-      "c * d", "c", "d", 
+      "c * d", "c", "d",
       "x.y", "x",
       "z(k, 2, 3)", "k",
       "o",

metadata

@@ -2,7 +2,7 @@
 name: sorcerer
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jim Weirich