ruby_scribe 0.0.4 → 0.1.0

data/lib/ruby_scribe/emitter.rb

@@ -4,26 +4,7 @@ module RubyScribe
   # Takes a proprocessed S-expression and emits formatted Ruby code
   class Emitter
     include EmitterHelpers
-    
-    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 = ['+', '-', '<<', '==', '===', '>', '<']
+    include EmitterConfig
     
     def emit(e)
       return "" unless e
@@ -65,7 +46,7 @@ module RubyScribe
         emit_multiple_assignment(e)
       when :cdecl
         emit_constant_declaration(e)
-      when :if, :unless
+      when :if
         emit_conditional_block(e)
       when :case
         emit_case_statement(e)
@@ -102,10 +83,10 @@ module RubyScribe
     end
     
     def emit_block(e)
-      return "" if e.body[0] == s(:nil)
+      return "" if e.body.first == s(:nil)
       
       # Special case for handling rescue blocks around entire methods (excluding the indent):
-      return emit_method_rescue(e.body[0]) if e.body.size == 1 and e.body[0].kind == :rescue
+      return emit_method_rescue(e.body.first) if e.body.first.rescue? && e.body.size == 1
       
       e.body.map do |child|
         emit_block_member_prefix(e.body, child) + 
@@ -113,6 +94,7 @@ module RubyScribe
       end.join(nl)
     end
     
+    # TODO: Clean up block member prefix emitting
     def emit_block_member_prefix(members, current_member)
       previous_member_index = members.index(current_member) - 1
       previous_member = previous_member_index >= 0 ? members[previous_member_index] : nil
@@ -125,17 +107,17 @@ module RubyScribe
         return nl if (from == :any || from.include?(previous_member.kind)) && (to == :any || to.include?(current_member.kind))
       end
       
-      if current_member.kind == :if && [:block_if, :block_unless].include?(determine_if_type(current_member))
+      if current_member.conditional? && [:block_if, :block_unless].include?(determine_if_type(current_member))
         return nl
-      elsif previous_member.kind == :if && [:block_if, :block_unless].include?(determine_if_type(previous_member))
+      elsif previous_member.conditional? && [:block_if, :block_unless].include?(determine_if_type(previous_member))
         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]))
+      if previous_member.call? && grouped_methods.include?(previous_member.name.to_s) && (!current_member.call? || (current_member.call? && current_member.name != previous_member.name))
         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]))
+      if current_member.call? && grouped_methods.include?(current_member.name.to_s) && (!previous_member.call? || (previous_member.call? && previous_member.name != current_member.name))
         return nl
       end
       
@@ -143,14 +125,14 @@ module RubyScribe
     end
     
     def emit_scope(e)
-      emit(e.body[0])
+      emit(e.body.first)
     end
     
     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]
+      rescue_sexp = e.body.first
+      block = rescue_sexp.body.size == 1 ? nil : rescue_sexp.body.first
+      resbody = rescue_sexp.body.size == 1 ? rescue_sexp.body.first : rescue_sexp.body.second
+      ensure_sexp = e.body.second
       
       "begin" + indent { nl + emit(block) } +
       emit(resbody) +
@@ -160,11 +142,11 @@ module RubyScribe
     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]
+      block = e.body.size == 1 ? nil : e.body.first
+      resbody = e.body.size == 1 ? e.body.first : e.body.second
       
-      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])}"
+      if !force_long && e.line == resbody.line && block.kind != :block && resbody && resbody.body.second && resbody.body.second.kind != :block
+        "#{emit(block)} rescue #{emit(resbody.body.second)}"
       else
         "begin" + indent { nl + emit(block) } +
         emit(resbody) +
@@ -174,12 +156,12 @@ module RubyScribe
     
     def emit_rescue_body(e)
       nl("rescue ".gsub(/ $/, '')) + 
-      indent { nl + emit(e.body[1]) }
+      indent { nl + emit(e.body.second) }
     end
     
     def emit_method_rescue(e)
-      block = e.body.size == 1 ? nil : e.body[0]
-      resbody = e.body.size == 1 ? e.body[0] : e.body[1]
+      block = e.body.size == 1 ? nil : e.body.first
+      resbody = e.body.size == 1 ? e.body.first : e.body.second
       
       emit(block) + 
       indent(-2) { emit(resbody) }
@@ -187,37 +169,37 @@ module RubyScribe
     
     def emit_class_definition(e)
       emit_comments(e.comments) + 
-      "#{e.kind} #{emit(e.body[0])}" + 
-      (e.body[1] ? " < #{emit(e.body[1])}" : "") +
-      indent { nl + emit(e.body[2]) } + 
+      "#{e.kind} #{emit(e.body.first)}" + 
+      (e.body.second ? " < #{emit(e.body.second)}" : "") +
+      indent { nl + emit(e.body.third) } + 
       nl("end")
     end
     
     def emit_self_class_definition(e)
-      "class << #{emit(e.body[0])}" + 
-      indent { nl + emit(e.body[1]) } + 
+      "class << #{emit(e.body.first)}" + 
+      indent { nl + emit(e.body.second) } + 
       nl("end")
     end
     
     def emit_module_definition(e)
       emit_comments(e.comments) +
-      "module #{emit(e.body[0])}" + 
-      indent { nl + emit(e.body[1]) } + 
+      "module #{emit(e.body.first)}" + 
+      indent { nl + emit(e.body.second) } + 
       nl("end")
     end
     
     def emit_method_definition(e)
       emit_comments(e.comments) + 
-      "def #{e.body[0]}" + 
-      (e.body[1].body.empty? ? "" : "(#{emit(e.body[1])})") +
-      indent { nl + emit(e.body[2]) } + 
+      "def #{e.body.first}" + 
+      (e.body.second.body.empty? ? "" : "(#{emit(e.body.second)})") +
+      indent { nl + emit(e.body.third) } + 
       nl("end")
     end
     
     def emit_method_with_receiver_definition(e)
       emit_comments(e.comments) +
-      "def #{emit(e.body[0])}.#{e.body[1]}" + 
-      (e.body[2].body.empty? ? "" : "(#{emit(e.body[2])})") +
+      "def #{emit(e.body.first)}.#{e.body.second}" + 
+      (e.body.third.body.empty? ? "" : "(#{emit(e.body.third)})") +
       indent { nl + emit(e.body[3]) } + 
       nl("end")
     end
@@ -227,7 +209,7 @@ module RubyScribe
         e.body.each do |child|
           if child.is_a?(Sexp) and child.kind == :block
             child.body.each do |body_child|
-              array[array.index(body_child.body[0])] = emit(body_child)
+              array[array.index(body_child.body.first)] = emit(body_child)
             end
           else
             array << child
@@ -237,8 +219,8 @@ module RubyScribe
     end
     
     def emit_method_call(e)
-      return emit_method_call_hash_access(e) if e.body[1] == :[]
-      return emit_method_call_hash_assignment(e) if e.body[1] == :[]=
+      return emit_method_call_hash_access(e) if e.body.second == :[]
+      return emit_method_call_hash_assignment(e) if e.body.second == :[]=
       
       emit_method_call_receiver(e) + 
       emit_method_call_name(e) + 
@@ -246,37 +228,37 @@ module RubyScribe
     end
     
     def emit_method_call_receiver(e)
-      if e.body[0] && SYNTACTIC_METHODS.include?(e.body[1].to_s)
-        "#{emit(e.body[0])} "
-      elsif e.body[0]
-        "#{emit(e.body[0])}."
+      if e.body.first && syntactic_methods.include?(e.body.second.to_s)
+        "#{emit(e.body.first)} "
+      elsif e.body.first
+        "#{emit(e.body.first)}."
       else
         ""
       end
     end
     
     def emit_method_call_name(e)
-      emit(e.body[1])
+      emit(e.body.second)
     end
     
     def emit_method_call_arguments(e)
-      if e.body[2].body.empty?
+      if e.body.third.body.empty?
         ""
-      elsif self.class.methods_without_parenthesis.include?(e.body[1].to_s)
-        " " + emit(e.body[2])
-      elsif SYNTACTIC_METHODS.include?(e.body[1].to_s)
-        " " + emit(e.body[2])
+      elsif methods_without_parenthesis.include?(e.body.second.to_s)
+        " " + emit(e.body.third)
+      elsif syntactic_methods.include?(e.body.second.to_s)
+        " " + emit(e.body.third)
       else
-        "(" + emit(e.body[2]) + ")"
+        "(" + emit(e.body.third) + ")"
       end
     end
     
     def emit_method_call_hash_access(e)
-      emit(e.body[0]) + "[" + emit(e.body[2]) + "]"
+      emit(e.body.first) + "[" + emit(e.body.third) + "]"
     end
     
     def emit_method_call_hash_assignment(e)
-      emit(e.body[0]) + "[" + emit(e.body[2].body[0]) + "] = " + emit(e.body[2].body[1])
+      emit(e.body.first) + "[" + emit(e.body.third.body.first) + "] = " + emit(e.body.third.body.second)
     end
     
     
@@ -291,36 +273,36 @@ module RubyScribe
     end
     
     def emit_attribute_assignment(e)
-      return emit_method_call(e) if ['[]='].include?(e.body[1].to_s)
+      return emit_method_call(e) if ['[]='].include?(e.body.second.to_s)
       
-      emit(e.body[0]) + "." + e.body[1].to_s.gsub(/=$/, "") + " = " + emit(e.body[2])
+      emit(e.body.first) + "." + e.body.second.to_s.gsub(/=$/, "") + " = " + emit(e.body.third)
     end
     
     def emit_class_variable_assignment(e)
-      emit(e.body[0]) + " = " + emit(e.body[1])
+      emit(e.body.first) + " = " + emit(e.body.second)
     end
     
     def emit_multiple_assignment(e)
-      left = e.body[0].body
-      right = e.body[1].body
+      left = e.body.first.body
+      right = e.body.second.body
       
-      left.map {|c| c.body[0] }.join(", ") + " = " + right.map {|c| emit(c) }.join(", ")
+      left.map {|c| c.body.first }.join(", ") + " = " + right.map {|c| emit(c) }.join(", ")
     end
     
     def emit_constant_declaration(e)
-      emit(e.body[0]) + " = " + emit(e.body[1])
+      emit(e.body.first) + " = " + emit(e.body.second)
     end
     
     def determine_if_type(e)
-      if e.body[1] && e.body[2] && e.body[0].line == e.body[1].try(:line) && e.line == e.body[2].try(:line)
+      if e.body.second && e.body.third && e.body.first.line == e.body.second.try(:line) && e.line == e.body.third.try(:line)
         :ternary
-      elsif e.body[1] && !e.body[2] && e.line == e.body[1].line && e.body[1].kind != :block
+      elsif e.body.second && !e.body.third && e.line == e.body.second.line && e.body.second.kind != :block
         :dangling_if
-      elsif !e.body[1] && e.body[2] && e.line == e.body[2].line && e.body[2].kind != :block
+      elsif !e.body.second && e.body.third && e.line == e.body.third.line && e.body.third.kind != :block
         :dangling_unless
-      elsif e.body[1]
+      elsif e.body.second
         :block_if
-      elsif e.body[2]
+      elsif e.body.third
         :block_unless
       end
     end
@@ -328,17 +310,17 @@ module RubyScribe
     def emit_conditional_block(e)
       case determine_if_type(e)
       when :ternary
-        "#{emit(e.body[0])} ? #{emit(e.body[1] || s(:nil))} : #{emit(e.body[2] || s(:nil))}"
+        "#{emit(e.body.first)} ? #{emit(e.body.second || s(:nil))} : #{emit(e.body.third || s(:nil))}"
       when :dangling_if
-        "#{emit(e.body[1])} if #{emit(e.body[0])}"
+        "#{emit(e.body.second)} if #{emit(e.body.first)}"
       when :dangling_unless
-        "#{emit(e.body[2])} unless #{emit(e.body[0])}"
+        "#{emit(e.body.third)} unless #{emit(e.body.first)}"
       when :block_if
-        "if #{emit(e.body[0])}" + indent { nl + emit(e.body[1]) } + 
-        emit_conditional_else_block(e.body[2]) +  
+        "if #{emit(e.body.first)}" + indent { nl + emit(e.body.second) } + 
+        emit_conditional_else_block(e.body.third) +  
         nl("end")
       when :block_unless
-        "unless #{emit(e.body[0])}" + indent { nl + emit(e.body[2]) } +
+        "unless #{emit(e.body.first)}" + indent { nl + emit(e.body.third) } +
         nl("end")
       end
     end
@@ -347,19 +329,19 @@ module RubyScribe
       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])
+        nl("elsif #{emit(e.body.first)}") + indent { nl + emit(e.body.second) } + 
+        emit_conditional_else_block(e.body.third)
       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")
+      "case #{emit(e.body.first)}".gsub(/ $/, '') + e.body[1..-2].map {|c| emit(c) }.join + emit_case_else_statement(e.body[-1]) + nl("end")
     end
     
     def emit_case_when_statement(e)
-      nl("when #{emit_case_when_argument(e.body.first)}") + indent { nl + emit(e.body[1]) }
+      nl("when #{emit_case_when_argument(e.body.first)}") + indent { nl + emit(e.body.second) }
     end
     
     def emit_case_else_statement(e)
@@ -375,57 +357,57 @@ module RubyScribe
     end
     
     def emit_loop_block(e)
-      "#{e.kind} #{emit(e.body[0])}" + 
-      indent { nl + emit(e.body[1]) } + 
+      "#{e.kind} #{emit(e.body.first)}" + 
+      indent { nl + emit(e.body.second) } + 
       nl("end")
     end
     
     def emit_for_block(e)
-      "for #{e.body[1].body[0]} in #{emit(e.body[0])}" + 
-      indent { nl + emit(e.body[2]) } + 
+      "for #{e.body.second.body.first} in #{emit(e.body.first)}" + 
+      indent { nl + emit(e.body.third) } + 
       nl("end")
     end
     
     def emit_assignment_expression(e)
-      "#{e.body[0]} = #{emit(e.body[1])}"
+      "#{e.body.first} = #{emit(e.body.second)}"
     end
     
     def emit_optional_assignment_expression(e)
-      emit(e.body[0]) + "[#{emit(e.body[1])}] #{emit(e.body[2])}= " + emit(e.body[3])
+      emit(e.body.first) + "[#{emit(e.body.second)}] #{emit(e.body.third)}= " + emit(e.body[3])
     end
     
     def emit_optional_assignment_or_expression(e)
-      emit(e.body[0]) + " ||= " + emit(e.body[1].body[1])
+      emit(e.body.first) + " ||= " + emit(e.body.second.body.second)
     end
     
     def emit_optional_assignment_and_expression(e)
-      emit(e.body[0]) + " &&= " + emit(e.body[1].body[1])
+      emit(e.body.first) + " &&= " + emit(e.body.second.body.second)
     end
     
     def emit_binary_expression(e)
-      "(" + emit(e.body[0]) + " " + 
+      "(" + emit(e.body.first) + " " + 
       (e.kind == :and ? "&&" : "||") + 
-      " " + emit(e.body[1]) + ")"
+      " " + emit(e.body.second) + ")"
     end
     
     def emit_block_invocation(e)
-      emit(e.body[0]) + emit_block_invocation_body(e)
+      emit(e.body.first) + emit_block_invocation_body(e)
     end
     
     def emit_block_invocation_body(e)
       # If it's on the same line, it should probably be shorthand form:
-      if e.line == e.body[2].try(:line)
-        " {#{emit_block_invocation_arguments(e)} #{emit(e.body[2])} }"
+      if e.line == e.body.third.try(:line)
+        " {#{emit_block_invocation_arguments(e)} #{emit(e.body.third)} }"
       else
         " do #{emit_block_invocation_arguments(e)}".gsub(/ +$/, '') + 
-        indent { nl + emit(e.body[2]) } + 
+        indent { nl + emit(e.body.third) } + 
         nl("end")
       end
     end
     
     def emit_block_invocation_arguments(e)
-      if e.body[1]
-        "|" + emit_assignments_as_arguments(e.body[1]) + "|"
+      if e.body.second
+        "|" + emit_assignments_as_arguments(e.body.second) + "|"
       else
         ""
       end
@@ -433,34 +415,34 @@ module RubyScribe
     
     def emit_assignments_as_arguments(e)
       if e.kind == :masgn
-        e.body[0].body.map {|c| emit_assignments_as_arguments(c) }.join(", ")
+        e.body.first.body.map {|c| emit_assignments_as_arguments(c) }.join(", ")
       elsif e.kind == :lasgn
-        e.body[0].to_s
+        e.body.first.to_s
       elsif e.kind == :splat
-        "*" + emit_assignments_as_arguments(e.body[0])
+        "*" + emit_assignments_as_arguments(e.body.first)
       end
     end
     
     def emit_defined_invocation(e)
-      "defined?(#{emit(e.body[0])})"
+      "defined?(#{emit(e.body.first)})"
     end
     
     def emit_token(e)
       case e.kind
       when :str
-        '"' + e.body[0] + '"'
+        '"' + e.body.first + '"'
       when :lit
-        e.body[0].inspect
+        e.body.first.inspect
       when :const
-        e.body[0].to_s
+        e.body.first.to_s
       when :lvar
-        e.body[0].to_s
+        e.body.first.to_s
       when :ivar
-        e.body[0].to_s
+        e.body.first.to_s
       when :cvar
-        e.body[0].to_s
+        e.body.first.to_s
       when :not
-        "!" + emit(e.body[0])
+        "!" + emit(e.body.first)
       when :true
         "true"
       when :false
@@ -482,41 +464,41 @@ module RubyScribe
       when :return
         "return #{emit_argument_list(e)}".strip
       when :alias
-        "alias #{emit(e.body[0])} #{emit(e.body[1])}"
+        "alias #{emit(e.body.first)} #{emit(e.body.second)}"
       when :block_pass
-        "&" + emit(e.body[0])
+        "&" + emit(e.body.first)
       when :splat
-        "*" + emit(e.body[0])
+        "*" + emit(e.body.first)
       when :colon2
-        "#{emit(e.body[0])}::#{emit(e.body[1])}"
+        "#{emit(e.body.first)}::#{emit(e.body.second)}"
       when :colon3
-        "::#{emit(e.body[0])}"
+        "::#{emit(e.body.first)}"
       when :dot2
-        "#{emit(e.body[0])}..#{emit(e.body[1])}"
+        "#{emit(e.body.first)}..#{emit(e.body.second)}"
       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
+        "$" + e.body.first.to_s
       when :gvar
-        e.body[0].to_s
+        e.body.first.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]) + '}'
+        '#{' + emit(e.body.first) + '}'
       when :xstr
-        '`' + emit(e.body[0]) + '`'
+        '`' + emit(e.body.first) + '`'
       when :dxstr
         '`' + literalize_strings(e.body).map {|c| emit(c) }.join + '`'
       when :dsym
         ':"' + literalize_strings(e.body).map {|c| emit(c) }.join + '"'
       when :match3
-        emit(e.body[1]) + " =~ " + emit(e.body[0])
+        emit(e.body.second) + " =~ " + emit(e.body.first)
       when :cvdecl
-        emit(e.body[0].to_s) + " = " + emit(e.body[1])
+        emit(e.body.first.to_s) + " = " + emit(e.body.second)
       else
         emit_unknown_expression(e)
       end
@@ -525,7 +507,7 @@ module RubyScribe
     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
+      if !force_short && grouped.size >= 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(", ")

data/lib/ruby_scribe/emitter_config.rb

@@ -0,0 +1,28 @@
+module RubyScribe
+  module EmitterConfig
+    extend ActiveSupport::Concern
+    
+    included do
+      attr_accessor :methods_without_parenthesis
+      attr_accessor :grouped_methods
+      attr_accessor :long_hash_key_size
+      attr_accessor :default_indent
+      attr_accessor :syntactic_methods
+    end
+    
+    def initialize
+      self.grouped_methods = %w(require attr_accessor autoload)
+      self.long_hash_key_size = 5
+      self.default_indent = 2
+      self.syntactic_methods = ['+', '-', '<<', '==', '===', '>', '<']
+      
+      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
+      )
+    end
+  end
+end

data/lib/ruby_scribe/emitter_helpers.rb

@@ -9,7 +9,7 @@ module RubyScribe
     end
     
     def indent(level = nil)
-      level = self.class.default_indent if level.nil?
+      level = default_indent if level.nil?
       
       indents.push(level)
       output = yield

data/lib/ruby_scribe/ext/sexp.rb

@@ -1,9 +1,3 @@
 class Sexp
-  def kind
-    sexp_type.to_sym
-  end
-  
-  def body
-    sexp_body
-  end
+  include RubyScribe::SexpHelpers
 end