ruby_scribe 0.0.2 → 0.0.3

data/README.rdoc

@@ -93,8 +93,7 @@ This feature is not developed yet, but is intended on presenting a standard recu
 == Known Issues
 
 * Since there are still some holes in the implementation, any s-expression type that is unknown will cause the following to be emitted: "## RubyScribe-UNKNOWN: :type ##".  Once stable any unknown type will instead throw an exception.
-* Anything involving order of operations currently much surround the expression in ( ).  Will probably expand later to omit this when order of operations is implied, but this requires a context stack.
-* Elsif currently does not work as you'd expect and instead embeds another if block inside of the outer one's "else".  This is how if statements are presented via ruby_parser.  
+* Anything involving order of operations currently much surround the expression in ( ).  Will probably expand later to omit this when order of operations is implied, but this requires a context stack.  There may actually be other issues related to order of operations.  To do this properly requires maintaining context of operations and, starting with the case for parenthesis, remove parentheses when the emitter determines that the order of operations is implied by Ruby syntax rules.  Right now the emitter more or less assumes order of operations is implied and does not use parantheses, except in the cases of || and && in which case it does.
 * Some of the more obscure types are not implemented.
 * Only comments on methods, class, and module declarations are retained.  This is actually a limitation of ruby_parser as for whatever reason 
 in-line comments cannot be parsed correctly.

data/lib/ruby_scribe.rb

@@ -4,5 +4,9 @@ require "ruby_parser"
 
 require "ruby_scribe/emitter_helpers"
 require "ruby_scribe/emitter"
-require "ruby_scribe/transformation"
+require "ruby_scribe/transformer"
 require "ruby_scribe/ext/sexp"
+
+Dir[File.join(File.dirname(__FILE__), "ruby_scribe/transformers/**/*.rb")].each do |file|
+  require file
+end

data/lib/ruby_scribe/emitter.rb

@@ -5,8 +5,23 @@ module RubyScribe
   class Emitter
     include EmitterHelpers
     
-    cattr_accessor :methods_without_parenthesis
-    self.methods_without_parenthesis = %w(require gem puts attr_accessor cattr_accessor delegate alias_method alias)
+    class_inheritable_accessor :methods_without_parenthesis
+    self.methods_without_parenthesis = %w(
+      attr_accessor attr_reader attr_writer
+      alias alias_method alias_attribute
+      gem require extend include raise
+      delegate autoload raise
+      puts
+    )
+    
+    class_inheritable_accessor :grouped_methods
+    self.grouped_methods = %w(require attr_accessor autoload)
+    
+    class_inheritable_accessor :long_hash_key_size
+    self.long_hash_key_size = 5
+    
+    class_inheritable_accessor :default_indent
+    self.default_indent = 2
     
     SYNTACTIC_METHODS = ['+', '-', '<<', '==', '===', '>', '<']
     
@@ -20,6 +35,8 @@ module RubyScribe
         emit_block(e)
       when :scope
         emit_scope(e)
+      when :ensure
+        emit_rescue_ensure_wrapper(e)
       when :rescue
         emit_rescue(e)
       when :resbody
@@ -42,6 +59,8 @@ module RubyScribe
         emit_argument_list(e)
       when :attrasgn
         emit_attribute_assignment(e)
+      when :cvasgn, :gasgn
+        emit_class_variable_assignment(e)
       when :masgn
         emit_multiple_assignment(e)
       when :cdecl
@@ -58,6 +77,8 @@ module RubyScribe
         emit_for_block(e)
       when :lasgn, :iasgn
         emit_assignment_expression(e)
+      when :op_asgn1, :op_asgn2
+        emit_optional_assignment_expression(e)
       when :op_asgn_or
         emit_optional_assignment_or_expression(e)
       when :op_asgn_and
@@ -110,6 +131,14 @@ module RubyScribe
         return nl
       end
       
+      if previous_member.kind == :call && self.class.grouped_methods.include?(previous_member.body[1].to_s) && (current_member.kind != :call || (current_member.kind == :call && current_member.body[1] != previous_member.body[1]))
+        return nl
+      end
+      
+      if current_member.kind == :call && self.class.grouped_methods.include?(current_member.body[1].to_s) && (previous_member.kind != :call || (previous_member.kind == :call && previous_member.body[1] != current_member.body[1]))
+        return nl
+      end
+      
       ""
     end
     
@@ -117,15 +146,32 @@ module RubyScribe
       emit(e.body[0])
     end
     
-    def emit_rescue(e)
-      block = e.body.size == 1 ? nil : e.body[0]
-      resbody = e.body.size == 1 ? e.body[0] : e.body[1]
+    def emit_rescue_ensure_wrapper(e)
+      rescue_sexp = e.body[0]
+      block = rescue_sexp.body.size == 1 ? nil : rescue_sexp.body[0]
+      resbody = rescue_sexp.body.size == 1 ? rescue_sexp.body[0] : rescue_sexp.body[1]
+      ensure_sexp = e.body[1]
       
       "begin" + indent { nl + emit(block) } +
       emit(resbody) +
+      nl("ensure") + 
+      indent { nl + emit(ensure_sexp) } +
       nl("end")
     end
     
+    def emit_rescue(e, force_long = false)
+      block = e.body.size == 1 ? nil : e.body[0]
+      resbody = e.body.size == 1 ? e.body[0] : e.body[1]
+      
+      if !force_long && e.line == resbody.line && block.kind != :block && resbody && resbody.body[1] && resbody.body[1].kind != :block
+        "#{emit(block)} rescue #{emit(resbody.body[1])}"
+      else
+        "begin" + indent { nl + emit(block) } +
+        emit(resbody) +
+        nl("end")
+      end
+    end
+    
     def emit_rescue_body(e)
       nl("rescue ".gsub(/ $/, '')) + 
       indent { nl + emit(e.body[1]) }
@@ -141,21 +187,21 @@ module RubyScribe
     
     def emit_class_definition(e)
       emit_comments(e.comments) + 
-      "#{e.kind} #{e.body[0]}" + 
+      "#{e.kind} #{emit(e.body[0])}" + 
       (e.body[1] ? " < #{emit(e.body[1])}" : "") +
       indent { nl + emit(e.body[2]) } + 
       nl("end")
     end
     
     def emit_self_class_definition(e)
-      "class << #{e.body[0]}" + 
+      "class << #{emit(e.body[0])}" + 
       indent { nl + emit(e.body[1]) } + 
       nl("end")
     end
     
     def emit_module_definition(e)
       emit_comments(e.comments) +
-      "#{e.kind} #{e.body[0]}" + 
+      "module #{emit(e.body[0])}" + 
       indent { nl + emit(e.body[1]) } + 
       nl("end")
     end
@@ -250,6 +296,10 @@ module RubyScribe
       emit(e.body[0]) + "." + e.body[1].to_s.gsub(/=$/, "") + " = " + emit(e.body[2])
     end
     
+    def emit_class_variable_assignment(e)
+      emit(e.body[0]) + " = " + emit(e.body[1])
+    end
+    
     def emit_multiple_assignment(e)
       left = e.body[0].body
       right = e.body[1].body
@@ -285,7 +335,7 @@ module RubyScribe
         "#{emit(e.body[2])} unless #{emit(e.body[0])}"
       when :block_if
         "if #{emit(e.body[0])}" + indent { nl + emit(e.body[1]) } + 
-        (e.body[2] ? (nl("else") + indent { nl + emit(e.body[2]) }) : "") + 
+        emit_conditional_else_block(e.body[2]) +  
         nl("end")
       when :block_unless
         "unless #{emit(e.body[0])}" + indent { nl + emit(e.body[2]) } +
@@ -293,6 +343,17 @@ module RubyScribe
       end
     end
     
+    def emit_conditional_else_block(e)
+      return "" unless e
+      
+      if e.kind == :if
+        nl("elsif #{emit(e.body[0])}") + indent { nl + emit(e.body[1]) } + 
+        emit_conditional_else_block(e.body[2])
+      else
+        nl("else") + indent { nl + emit(e) }
+      end
+    end
+    
     def emit_case_statement(e)
       "case #{emit(e.body[0])}".gsub(/ $/, '') + e.body[1..-2].map {|c| emit(c) }.join + emit_case_else_statement(e.body[-1]) + nl("end")
     end
@@ -329,6 +390,10 @@ module RubyScribe
       "#{e.body[0]} = #{emit(e.body[1])}"
     end
     
+    def emit_optional_assignment_expression(e)
+      emit(e.body[0]) + "[#{emit(e.body[1])}] #{emit(e.body[2])}= " + emit(e.body[3])
+    end
+    
     def emit_optional_assignment_or_expression(e)
       emit(e.body[0]) + " ||= " + emit(e.body[1].body[1])
     end
@@ -360,7 +425,7 @@ module RubyScribe
     
     def emit_block_invocation_arguments(e)
       if e.body[1]
-        "|" + emit_assignments_as_arguments(e.body[1]) + "| "
+        "|" + emit_assignments_as_arguments(e.body[1]) + "|"
       else
         ""
       end
@@ -392,6 +457,8 @@ module RubyScribe
         e.body[0].to_s
       when :ivar
         e.body[0].to_s
+      when :cvar
+        e.body[0].to_s
       when :not
         "!" + emit(e.body[0])
       when :true
@@ -421,15 +488,23 @@ module RubyScribe
       when :splat
         "*" + emit(e.body[0])
       when :colon2
-        "#{emit(e.body[0])}::#{e.body[1].to_s}"
+        "#{emit(e.body[0])}::#{emit(e.body[1])}"
+      when :colon3
+        "::#{emit(e.body[0])}"
+      when :dot2
+        "#{emit(e.body[0])}..#{emit(e.body[1])}"
       when :hash
         "{" + emit_hash_body(e) + "}"
       when :array
         "[" + e.body.map {|c| emit(c)}.join(", ") + "]"
+      when :nth_ref, :back_ref
+        "$" + e.body[0].to_s
       when :gvar
         e.body[0].to_s
       when :dstr
         '"' + literalize_strings(e.body).map {|c| emit(c) }.join + '"'
+      when :dregx
+        '/' + literalize_strings(e.body).map {|c| emit(c) }.join + '/'
       when :evstr
         '#{' + emit(e.body[0]) + '}'
       when :xstr
@@ -447,8 +522,14 @@ module RubyScribe
       end
     end
     
-    def emit_hash_body(e)
-      e.body.in_groups_of(2).map {|g| "#{emit(g[0])} => #{emit(g[1])}" }.join(", ")
+    def emit_hash_body(e, force_short = false)
+      grouped = e.body.in_groups_of(2)
+      
+      if !force_short && grouped.size >= self.class.long_hash_key_size
+        indent(2) { nl + grouped.map {|g| "#{emit(g[0])} => #{emit(g[1])}" }.join("," + nl) } + nl
+      else
+        grouped.map {|g| "#{emit(g[0])} => #{emit(g[1])}" }.join(", ")
+      end
     end
     
     def emit_unknown_expression(e)

data/lib/ruby_scribe/emitter_helpers.rb

@@ -8,7 +8,9 @@ module RubyScribe
       indents.inject(0) {|b,i| b + i } || 0
     end
     
-    def indent(level = 2)
+    def indent(level = nil)
+      level = self.class.default_indent if level.nil?
+      
       indents.push(level)
       output = yield
       indents.pop

data/lib/ruby_scribe/transformer.rb

@@ -0,0 +1,15 @@
+module RubyScribe
+  # Takes a raw S-expression and transforms it (replaces the node with the return value of the process method).
+  # This is meant to be subclassed, and in the process method you should either return a transformed version of the node, 
+  # or just call super which will leave the node in place and iterate through the children.
+  # 
+  class Transformer
+    def transform(sexp)
+      if sexp.is_a?(Sexp)
+        Sexp.new(*([sexp.kind] + sexp.body.map {|c| transform(c) }))
+      else
+        sexp
+      end
+    end
+  end
+end

data/lib/ruby_scribe/transformers/eachifier.rb

@@ -0,0 +1,21 @@
+module RubyScribe
+  module Transformers
+    class Eachifier < Transformer
+      def transform(e)
+        if e.is_a?(Sexp) && e.kind == :for
+          transform_for_to_each(e)
+        else
+          super
+        end
+      end
+      
+      def transform_for_to_each(e)
+        s(:iter, 
+          s(:call, e.body[0], :each, s(:arglist)), 
+          e.body[1],
+          e.body[2]
+        )
+      end
+    end
+  end
+end

data/lib/ruby_scribe/version.rb

@@ -1,3 +1,3 @@
 module RubyScribe
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/examples/identity.rb

@@ -1,4 +1,5 @@
 require "some_file"
+
 $:.unshift("directory")
 
 module RubyScribe
@@ -10,8 +11,35 @@ module RubyScribe
     end
   end
   
+  class Test
+    @@class_variable = 1
+  end
+  
   class MyClass < Subclass
     attr_accessor :no_parathesis
+    
     call_method("Apartness")
+    
+    single_line_block {|a| a.do_something }
+  end
+  
+  if a == 1
+    1
+  elsif a > 3
+    2
+  else
+    3
+  end
+  
+  if a == 1
+    1
+  else
+    if a > 3
+      2
+    else
+      3
+    end
+    
+    do_something_now
   end
 end

data/spec/examples/spacing.rb

@@ -0,0 +1,21 @@
+class One
+  def method_1
+    
+  end
+  
+  def method_2
+    
+  end
+end
+
+class Two
+  
+end
+
+require "test1"
+require "test2"
+
+another_method
+yet_another_method
+
+attr_accessor :test

data/spec/matchers/should_transform_to.rb

@@ -0,0 +1,21 @@
+RSpec::Matchers.define :transform_to do |desc, expected|
+  match do |actual|
+    actual_as_sexp = actual.is_a?(String) ? RubyParser.new.parse(actual) : actual
+    expected_as_sexp = expected.is_a?(String) ? RubyParser.new.parse(expected) : expected
+    
+    @transformed = described_class.new.transform(actual_as_sexp)
+    @transformed == expected_as_sexp
+  end
+  
+  failure_message_for_should do |actual|
+    "expected that:\n\n#{actual}\n\nwould transform to:\n\n#{expected}\n\nbut instead was:\n\n#{@transformed}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected that:\n\n#{actual}\n\nwould not transform to:\n\n#{expected}\n\nbut instead was:\n\n#{@transformed}"
+  end
+  
+  description do
+    "transform with to #{desc}"
+  end
+end

data/spec/ruby_scribe/emitter_spec.rb

@@ -15,15 +15,11 @@ describe RubyScribe::Emitter do
     end
     
     specify "namespaced class should emit itself" do
-      pending do
-        %{class Scribe::Animal\n  \nend}.should emit_itself
-      end
+      %{class Scribe::Animal\n  \nend}.should emit_itself
     end
     
     specify "eigenclass should emit itself" do
-      pending do
-        %{class << self\n  \nend}.should emit_itself
-      end
+      %{class << self\n  \nend}.should emit_itself
     end
   end
   
@@ -33,9 +29,7 @@ describe RubyScribe::Emitter do
     end
     
     specify "namespaced class should emit itself" do
-      pending do
-        %{module Scribe::Animal\n  \nend}.should emit_itself
-      end
+      %{module Scribe::Animal\n  \nend}.should emit_itself
     end
   end
   
@@ -44,144 +38,260 @@ describe RubyScribe::Emitter do
       %{begin\n  \nrescue\n  \nend}.should emit_itself
     end
     
+    specify "rescue all with ensure should emit itself" do
+      %{begin\n  \nrescue\n  \nensure\n  nil\nend}.should emit_itself
+    end
+    
     specify "method-wide rescue should emit itself" do
       %{def method\n  \nrescue\n  \nend}.should emit_itself
     end
+    
+    specify "dangling rescue should emit itself" do
+      %{do_something rescue nil}.should emit_itself
+    end
+    
+    specify "rescuing with exception class should emit itself" do
+      pending do
+        %{begin\n  \nrescue StandardError\n  \nend}.should emit_itself
+      end
+    end
+    
+    specify "rescuing with multiple exception classes should emit itself" do
+      pending do
+        %{begin\n  \nrescue StandardError\n  \nend}.should emit_itself
+      end
+    end
+    
+    specify "rescuing with exception class and target variable should emit itself" do
+      pending do
+        %{begin\n  \nrescue StandardError => e\n  \nend}.should emit_itself
+      end
+    end
   end
   
   context "method definition" do
-    specify "without arguments" do
+    specify "without arguments should emit itself" do
       %{def method\n  \nend}.should emit_itself
     end
     
-    specify "with one argument" do
+    specify "with one argument should emit itself" do
       %{def method(one)\n  \nend}.should emit_itself
     end
     
-    specify "with multiple arguments" do
+    specify "with multiple arguments should emit itself" do
       %{def method(one, two)\n  \nend}.should emit_itself
     end
     
-    specify "with optional arguments" do
+    specify "with optional arguments should emit itself" do
       %{def method(one = 1, two = {})\n  \nend}.should emit_itself
     end
     
-    specify "with block argument" do
+    specify "with block argument should emit itself" do
       %{def method(one, &two)\n  \nend}.should emit_itself
     end
   end
   
   context "method call" do
-    specify "without arguments" do
+    specify "without arguments should emit itself" do
       %{method}.should emit_itself
     end
     
-    specify "with one argument" do
+    specify "with one argument should emit itself" do
       %{method("One")}.should emit_itself
     end
     
-    specify "with multiple arguments" do
+    specify "with multiple arguments should emit itself" do
       %{method("One", 2)}.should emit_itself
     end
     
-    specify "with last argument as a hash" do
+    specify "with last argument as a hash should emit itself" do
       %{method("One", :option => :one)}.should emit_itself
     end
     
-    specify "with block" do
+    specify "with block should emit itself" do
       %{method do\n  \nend}.should emit_itself
     end
   end
   
   context "case statement" do
-    specify "with argument" do
+    specify "with argument should emit itself" do
       %{case something\nwhen 1\n  \nend}.should emit_itself
     end
     
-    specify "without argument" do
+    specify "without argument should emit itself" do
       %{case\nwhen 1 == 1\n  \nend}
     end
     
-    specify "with else block" do
+    specify "with else block should emit itself" do
       %{case something\nwhen 1\n  \nelse\n  2\nend}.should emit_itself
     end
   end
   
-  context "attribute assignment" do
-    specify "to simple local variable" do
+  context "assignment" do
+    specify "to global variable should emit itself" do
+      %{$variable = 1}.should emit_itself
+    end
+    
+    specify "to simple local variable should emit itself" do
       %{variable = 1}.should emit_itself
     end
     
-    specify "to instance variable" do
+    specify "to instance variable should emit itself" do
       %{@variable = 1}.should emit_itself
     end
     
-    specify "to multiple variables" do
+    specify "to class variable should emit itself" do
+      %{@@variable = 1}.should emit_itself
+    end
+    
+    specify "to class variable inside a method should emit itself" do
+      %{def hi\n  @@variable = 1\nend}.should emit_itself
+    end
+    
+    specify "to multiple variables should emit itself" do
       %{variable_1, variable_2 = 1, 2}.should emit_itself
     end
     
-    specify "with or" do
+    specify "with or should emit itself" do
       %{@variable ||= 1}.should emit_itself
     end
     
-    specify "with and" do
+    specify "with and should emit itself" do
       %{@variable &&= 1}.should emit_itself
     end
+    
+    specify "with hash should emit itself" do
+      %{@variable["something"] ||= 1}.should emit_itself
+    end
   end
   
   context "conditionals" do
-    specify "simple block if" do
+    specify "simple block if should emit itself" do
       %{if true\n  something\nend}.should emit_itself
     end
     
-    specify "simple block unless" do
+    specify "simple block unless should emit itself" do
       %{unless true\n  something\nend}.should emit_itself
     end
     
-    specify "simple block if else" do
+    specify "simple block if else should emit itself" do
       %{if true\n  something\nelse\n  something_else\nend}.should emit_itself
     end
     
-    specify "dangling if" do
+    specify "dangling if should emit itself" do
       %{something if true}.should emit_itself
     end
     
-    specify "dangling unless" do
+    specify "dangling unless should emit itself" do
       %{something unless true}.should emit_itself
     end
     
-    specify "ternary if" do
+    specify "ternary if should emit itself" do
       %{something ? true : false}.should emit_itself
     end
   end
   
   context "looping expression definition" do
-    specify "while" do
+    specify "while should emit itself" do
       %{while true\n  \nend}.should emit_itself
     end
     
-    specify "until" do
+    specify "until should emit itself" do
       %{until true\n  \nend}.should emit_itself
     end
     
-    specify "for in array" do
+    specify "for in array should emit itself" do
       %{for something in array\n  \nend}.should emit_itself
     end
   end
   
   context "binary expressions" do
-    specify "||" do
+    specify "|| should emit itself" do
       %{(one || two)}.should emit_itself
     end
     
-    specify "&&" do
+    specify "&& should emit itself" do
       %{(one && two)}.should emit_itself
     end
   end
   
   context "unary expressions" do
-    specify "!something" do
+    specify "!something should emit itself" do
       %{!something}.should emit_itself
     end
   end
+  
+  context "return statement" do
+    specify "with no argument should emit itself" do
+      %{return}.should emit_itself
+    end
+    
+    specify "with single argument should emit itself" do
+      %{return 1}.should emit_itself
+    end
+    
+    specify "with multiple arguments should emit itself" do
+      %{return [1, 2]}.should emit_itself
+    end
+  end
+  
+  context "literals" do
+    specify "short string should emit itself" do
+      %{"my string"}.should emit_itself
+    end
+    
+    specify "short string with interpolation should emit itself" do
+      '"my #{test} string"'.should emit_itself
+    end
+    
+    specify "heredoc string should emit itself" do
+      pending do
+        %{<<EOF\n  my strong\n  line 2\n  line 3\n  line 4\nEOF}.should emit_itself
+      end
+    end
+    
+    specify "short hash should emit itself" do
+      %{{:hash => :one, :another => :two}}.should emit_itself
+    end
+    
+    specify "long hash should emit itself" do
+      %{{\n  :key1 => :value1,\n  :key2 => :value2,\n  :key3 => :value3,\n  :key4 => :value4,\n  :key5 => :value5,\n  :key6 => :value6\n}}.should emit_itself
+    end
+    
+    specify "range with two dots should emit itself" do
+      %{1..10}.should emit_itself
+    end
+    
+    specify "range with three dots should emit itself" do
+      %{1...10}.should emit_itself
+    end
+    
+    specify "regular expression should emit itself" do
+      %{/[a-zA-Z]$/}.should emit_itself
+    end
+    
+    specify "regular expression with interpolation should emit itself" do
+      '/[a-Z#{something}]/'.should emit_itself
+    end
+    
+    specify "__FILE__ should emit itself" do
+      pending("requires a patch to ruby_parser which cannot parse this") do
+        %{__FILE__}.should emit_itself
+      end
+    end
+    
+    specify "__LINE__ should emit itself" do
+      pending("requires a patch to ruby_parser which cannot parse this") do
+        %{__LINE__}.should emit_itself
+      end
+    end
+    
+    specify "numeric reference should emit itself" do
+      %{$1}.should emit_itself
+    end
+    
+    specify "backreference should emit itself" do
+      %{$&}.should emit_itself
+    end
+  end
 end

data/spec/ruby_scribe/transformer_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe RubyScribe::Transformer do
+  
+  describe "a for block" do
+    subject { %{
+      def my_method
+        call_something
+      
+        for element in array
+          do_something(element)
+        end
+      end
+    }}
+    
+    it { should transform_to("the same", %{
+      def my_method
+        call_something
+      
+        for element in array
+          do_something(element)
+        end
+      end
+    }) }
+  end
+  
+end

data/spec/ruby_scribe/transformers/eachifier_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe RubyScribe::Transformers::Eachifier do
+  
+  describe "a for block" do
+    subject { %{
+      def my_method
+        call_something
+      
+        for element in array
+          do_something(element)
+        end
+      end
+    }}
+    
+    it { should transform_to("each", %{
+      def my_method
+        call_something
+        
+        array.each do |element|
+          do_something(element)
+        end
+      end
+    }) }
+  end
+  
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ruby_scribe
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Ben Hughes
@@ -77,21 +77,23 @@ files:
 - lib/ruby_scribe/emitter_helpers.rb
 - lib/ruby_scribe/ext/sexp.rb
 - lib/ruby_scribe/runner.rb
-- lib/ruby_scribe/transformation.rb
+- lib/ruby_scribe/transformer.rb
+- lib/ruby_scribe/transformers/eachifier.rb
 - lib/ruby_scribe/version.rb
 - lib/ruby_scribe.rb
-- lib/tasks/scribe.rake
 - spec/examples/identity.rb
+- spec/examples/spacing.rb
 - spec/matchers/should_emit_as.rb
 - spec/matchers/should_emit_itself.rb
+- spec/matchers/should_transform_to.rb
 - spec/ruby_scribe/emitter_examples_spec.rb
 - spec/ruby_scribe/emitter_spec.rb
-- spec/ruby_scribe/transformation_spec.rb
+- spec/ruby_scribe/transformer_spec.rb
+- spec/ruby_scribe/transformers/eachifier_spec.rb
 - spec/spec_helper.rb
 - LICENSE
 - Rakefile
 - README.rdoc
-- TODO.rdoc
 - bin/rubyscribe
 has_rdoc: true
 homepage: http://github.com/rubiety/ruby_scribe

data/TODO.rdoc

@@ -1,2 +0,0 @@
-= TODO
-

data/lib/ruby_scribe/transformation.rb

@@ -1,9 +0,0 @@
-module RubyScribe
-  # Takes a raw S-expression and proprocesses it.  To use, simply subclass and override the preprocess method.
-  # Catch any instances you want to handle as it drills down the chain
-  class Preprocessor
-    def proprocess(sexp)
-      
-    end
-  end
-end

data/lib/tasks/scribe.rake

@@ -1,29 +0,0 @@
-namespace :scribe do
-  desc "Run Scribe Examples"
-  task :examples do
-    $:.unshift(File.join(File.dirname(__FILE__), ".."))
-    require "ruby_parser"
-    require "ruby_scribe"
-    require "pp"
-    
-    original_file = File.read(File.join(File.dirname(__FILE__), "../../spec/examples/simple_class_with_methods.rb"))
-    sexp = RubyParser.new.parse(original_file)
-    
-    puts "Parsed S-Expresssion"
-    puts "======================================"
-    pp sexp
-    puts
-    
-    puts "Original File"
-    puts "======================================"
-    puts original_file
-    
-    puts
-    puts
-    
-    puts "Parsed File"
-    puts "======================================"
-    parsed_file = RubyScribe::Emitter.new.emit(sexp)
-    puts parsed_file
-  end
-end

data/spec/ruby_scribe/transformation_spec.rb

@@ -1,7 +0,0 @@
-require "spec_helper"
-
-describe RubyScribe::Preprocessor do
-  subject { RubyScribe::Proprocessor.new }
-  
-  
-end