to_source 0.1.3 → 0.2.0

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -1,3 +1,14 @@
+language: ruby
+bundler_args: --without guard metrics
+script: "bundle exec rake spec"
 rvm:
-  - rbx-18mode
+  #- 1.8.7
+  - 1.9.2
+  - 1.9.3
+  #- jruby-18mode # JRuby in 1.8 mode, no cextension support on travis
+  #- jruby-19mode # JRuby in 1.9 mode, no cextension support on travis
+  #- rbx-18mode
   - rbx-19mode
+notifications:
+  email:
+    - mbj@seonic.net

data/Changelog.md

@@ -0,0 +1,11 @@
+# v0.2.0 2012-12-07
+
+* [BRAKING CHANGE] Remove core extension Rubinius::AST::Node#to_source (mbj)
+* [feature] Add support for MRI via melbourne gem (mbj)
+* [fixed] 100% Yard covered documentation (mbj)
+* [fixed] Emit most binary operators without parantheses (mbj)
+* [feature] Port tests to rspec2 and greatly improve coverage and layout of these.
+* [feature] Introduce metric tools via devtools
+* [fixed] Lots of transitvity edge cases
+
+[Compare v0.1.3..v0.2.0](https://github.com/solnic/virtus/compare/v0.1.3...v0.2.0)

data/Gemfile

@@ -1,5 +1,8 @@
-source "http://rubygems.org"
+source :rubygems
 
-# Specify your gem's dependencies in to_source.gemspec
 gemspec
-gem 'rake'
+
+gem 'mutant-melbourne', :git => 'https://github.com/mbj/melbourne.git'
+gem 'devtools',         :git => 'https://github.com/mbj/devtools.git', :branch => 'rspec-2-mutant'
+
+eval File.read('Gemfile.devtools')

data/Gemfile.devtools

@@ -0,0 +1,52 @@
+group :development do 
+  gem 'rake',    '~> 0.9.2'
+  gem 'rspec',   '~> 2.12.0'
+  gem 'yard',    '~> 0.8.3'
+end
+
+group :guard do
+  gem 'guard',         '~> 1.5.4'
+  gem 'guard-bundler', '~> 1.0.0'
+  gem 'guard-rspec',   '~> 2.1.1'
+  gem 'rb-inotify', :git => 'https://github.com/mbj/rb-inotify'
+end
+
+group :benchmarks do
+  gem 'rbench', '~> 0.2.3'
+end
+
+platform :jruby do
+  group :jruby do
+    gem 'jruby-openssl', '~> 0.7.4'
+  end
+end
+
+group :metrics do
+  gem 'flay',      '~> 1.4.2'
+  gem 'flog',      '~> 2.5.1'
+  gem 'reek',      '~> 1.2.8', :git => 'https://github.com/dkubb/reek.git'
+  gem 'roodi',     '~> 2.1.0'
+  gem 'yardstick', '~> 0.7.0'
+  gem 'simplecov'
+
+  platforms :ruby_18, :ruby_19 do
+    # this indirectly depends on ffi which does not build on ruby-head
+    gem 'yard-spellcheck', '~> 0.1.5'
+  end
+
+  platforms :mri_18 do
+    gem 'arrayfields', '~> 4.7.4'  # for metric_fu
+    gem 'fattr',       '~> 2.2.0'  # for metric_fu
+    gem 'json',        '~> 1.7.3'  # for metric_fu rake task
+    gem 'map',         '~> 6.0.1'  # for metric_fu
+    gem 'metric_fu',   '~> 2.1.1'
+    gem 'mspec',       '~> 1.5.17'
+    gem 'rcov',        '~> 1.0.0'
+  end
+
+  platforms :rbx do
+    gem 'pelusa', '~> 0.2.1'
+    gem 'anima',  '~> 0.0.1', :git => 'https://github.com/mbj/anima.git'
+    gem 'mutant', '~> 0.0.1', :git => 'https://github.com/mbj/mutant.git'
+  end
+end

data/Guardfile

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+guard :bundler do
+  watch('Gemfile')
+end
+
+guard :rspec do
+  # run all specs if the spec_helper or supporting files files are modified
+  watch('spec/spec_helper.rb')                      { 'spec' }
+  watch(%r{\Aspec/(?:lib|support|shared)/.+\.rb\z}) { 'spec' }
+
+  # run unit specs if associated lib code is modified
+  watch(%r{\Alib/(.+)\.rb\z})                                         { |m| Dir["spec/unit/#{m[1]}"] }
+  watch("lib/#{File.basename(File.expand_path('../', __FILE__))}.rb") { 'spec'                       }
+
+  # run a spec if it is modified
+  watch(%r{\Aspec/(?:unit|integration)/.+_spec\.rb\z})
+end

data/README.md

@@ -0,0 +1,68 @@
+to_source
+=========
+
+[![Build Status](https://secure.travis-ci.org/mbj/to_source.png?branch=master)](http://travis-ci.org/mbj/to_source)
+[![Dependency Status](https://gemnasium.com/mbj/to_source.png)](https://gemnasium.com/mbj/to_source)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/mbj/to_source)
+
+Reverse parser to generate source code from the Rubinius AST. Also works well under MRI. 
+
+Installation
+------------
+
+Install the gem ```to_source``` via your preferred method.
+
+Examples
+--------
+
+```ruby
+require 'to_source'
+some_code = "a = 123"
+ast = some_code.to_ast
+# => #<Rubinius::AST::LocalVariableAssignment:0x21b8
+#       @value=#<Rubinius::AST::FixnumLiteral:0x21bc @value=123 @line=1>
+#       @variable=nil @line=1 @name=:a>
+ast.to_source
+# => "a = 123"
+```
+
+Credits
+-------
+
+* [Josep M. Bach (Txus)](http://txustice.me), [@txustice](http://twitter.com/txustice) on twitter
+* [Markus Schirp (mbj)](https://github.com/mbj), [@_m_b_j_](http://twitter.com/_m_b_j_) on twitter
+
+Contributing
+-------------
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with Rakefile or version
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+License
+-------
+
+Copyright (c) 2012 Josep M. Bach (Txus), Markus Schirp (mbj)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,10 +1,5 @@
-require "bundler/gem_tasks"
+require 'rake'
 
-require 'rake/testtask'
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.test_files = FileList['test/**/*_test.rb']
-  t.verbose = true
-end
+require 'devtools'
 
-task :default => :test
+Devtools.init

data/TODO

@@ -0,0 +1,5 @@
+* Fix parsing errors from ruby parser
+  It breaks on def $keyword.
+* Do a metric driven refactor once flay flog and friends work.
+* Report bug about missing Rubinius::AST::SClass#body
+* Decide about to support 18-mode or not

data/bin/to_source

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'to_source'
+
+ARGV.each do |path|
+  source = File.read(path)
+  ast = source.to_ast
+  next if ast.nil? # When file only has comments
+  $stderr.puts(path)
+  begin 
+    $stdout.puts(ToSource.to_source(ast))
+  rescue
+    ast.ascii_graph
+    raise
+  end
+end

data/config/flay.yml

@@ -0,0 +1,3 @@
+---
+threshold: 18
+total_score: 296

data/config/flog.yml

@@ -0,0 +1,2 @@
+---
+threshold: 14.4

data/config/roodi.yml

@@ -0,0 +1,26 @@
+---
+AbcMetricMethodCheck:
+  score: 12.2
+AssignmentInConditionalCheck:    {}
+CaseMissingElseCheck:            {}
+ClassLineCountCheck:
+  line_count: 324
+ClassNameCheck:                  
+  pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/
+ClassVariableCheck:              {}
+CyclomaticComplexityBlockCheck:
+  complexity: 2
+CyclomaticComplexityMethodCheck:
+  complexity: 4
+EmptyRescueBodyCheck:            {}
+ForLoopCheck:                    {}
+MethodLineCountCheck:
+  line_count: 9
+MethodNameCheck:
+  pattern: !ruby/regexp /\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|<<|[+*&|-])\z/
+ModuleLineCountCheck:
+  line_count: 327
+ModuleNameCheck:
+  pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/
+ParameterNumberCheck:
+  parameter_count: 3

data/config/site.reek

@@ -0,0 +1,93 @@
+---
+UncommunicativeParameterName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LargeClass:
+  max_methods: 10
+  exclude: 
+  - "Mutant::Matcher::Method" # 13 methods
+  enabled: true
+  max_instance_variables: 3
+UncommunicativeMethodName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+LongParameterList:
+  max_params: 2
+  exclude: 
+  - "Mutant::Context::Constant#initialize" # 3 params
+  enabled: true
+  overrides: {}
+FeatureEnvy:
+  exclude: []
+  enabled: true
+ClassVariable:
+  exclude: []
+  enabled: true
+BooleanParameter:
+  exclude: []
+  enabled: true
+IrresponsibleModule:
+  exclude: []
+  enabled: true
+UncommunicativeModuleName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+NestedIterators:
+  ignore_iterators: []
+  exclude: []
+  enabled: true
+  max_allowed_nesting: 1
+LongMethod:
+  max_statements: 6
+  exclude: []
+  enabled: true
+Duplication:
+  allow_calls: []
+  exclude: []
+  enabled: true
+  max_calls: 1
+UtilityFunction:
+  max_helper_calls: 0
+  exclude: []
+  enabled: true
+Attribute:
+  exclude: []
+  enabled: false
+UncommunicativeVariableName:
+  accept: []
+  exclude: []
+  enabled: true
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+SimulatedPolymorphism:
+  exclude: []
+  enabled: true
+  max_ifs: 1
+DataClump:
+  exclude: []
+  enabled: true
+  max_copies: 2
+  min_clump_size: 2
+ControlCouple:
+  exclude: []
+  enabled: true
+LongYieldList:
+  max_params: 1
+  exclude: []
+  enabled: true

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/lib/to_source.rb

@@ -1,16 +1,18 @@
-require "to_source/version"
-require "to_source/core_ext/node"
-require "to_source/visitor"
+require 'melbourne'
+require 'to_source/version'
+require 'to_source/visitor'
 
+# Namespace of library
 module ToSource
-  # Public: Converts the node back to its original source code.
+  # Convert node to string
   #
-  # Returns the String output.
-  def to_source
-    visitor = Visitor.new
-    lazy_visit(visitor)
-    visitor.output
+  # @param [Rubinius::AST::Node] node
+  #
+  # @return [String]
+  #
+  # @api private
+  #
+  def self.to_source(node)
+    Visitor.run(node)
   end
 end
-
-Rubinius::AST::Node.send :include, ToSource

data/lib/to_source/version.rb

@@ -1,3 +1,3 @@
 module ToSource
-  VERSION = "0.1.3"
+  VERSION = '0.2.0'
 end

data/lib/to_source/visitor.rb

@@ -1,189 +1,1276 @@
 module ToSource
+  # Converter from AST to source
   class Visitor
-    def initialize
+
+    # Create source code from AST node
+    #
+    # @param [Rubinius::AST::Node] node
+    #   the node to convert to source code
+    #
+    # @return [String]
+    #   returns the source code for ast node
+    #
+    # @api private
+    #
+    def self.run(node)
+      new(node).output
+    end
+
+    # Return the source code of AST
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def output
+      @output.join
+    end
+
+  private
+
+    # Initialize visitor
+    # 
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(node)
       @output = []
       @indentation = 0
+      dispatch(node)
     end
 
-    def emit(code)
-      @output.push code
+    # Dispatch node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dispatch(node)
+      name = node.node_name
+      name = "#{name}_def" if %w[ class module ].include?(name)
+      __send__(name, node)
     end
 
-    def output
-      @output.join
+    # Emit file
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def file(node)
+      emit('__FILE__')
+    end
+
+    # Emit element assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def element_assignment(node)
+      index, value = node.arguments.array
+      dispatch(node.receiver)
+      emit('[')
+      dispatch(index)
+      emit('] = ')
+      dispatch(value)
+    end
+
+    # Emit alias
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def alias(node)
+      emit("alias #{node.to.value} #{node.from.value}")
     end
 
+    # Emit match operator
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def match3(node)
+      dispatch(node.value)
+      emit(' =~ ')
+      dispatch(node.pattern)
+    end
+
+    # Emit break
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def break(node)
+      emit('break')
+    end
+
+    # Emit next
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def next(node)
+      emit('next')
+    end
+
+    # Emit conditional element assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def op_assign1(node)
+      receiver(node)
+      emit('[')
+      dispatch(node.arguments.array.first)
+      emit('] ||= ')
+      dispatch(node.value)
+    end
+
+    # Emit attribute assignment after merge
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def op_assign2(node)
+      dispatch(node.receiver)
+      emit('.')
+      emit(node.name)
+      emit(' |= ')
+      dispatch(node.value)
+    end
+
+    # Emit rescue
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def rescue(node)
+      body(node.body)
+      rescue_condition(node.rescue)
+    end
+
+    # Emit rescue condition
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def rescue_condition(node)
+      emit('rescue')
+      if node.conditions
+        body = node.conditions.body
+        first = body.first
+        unless body.one? and first.kind_of?(Rubinius::AST::ConstantAccess) and first.name == :StandardError
+          emit(' ')
+          array_body(body)
+        end
+      end
+
+      if node.splat
+        emit(',') if node.conditions
+        emit(' ')
+        dispatch(node.splat)
+      end
+
+      if node.assignment
+        emit(' => ')
+        emit(node.assignment.name)
+      end
+      nl
+      body(node.body)
+
+      if node.next
+        dispatch(node.next)
+      end
+    end
+
+    # Emit rescue splat
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def rescue_splat(node)
+      emit('*')
+      dispatch(node.value)
+    end
+
+    # Emit ensure
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def ensure(node)
+      body(node.body)
+      emit('ensure')
+      nl
+      body(node.ensure)
+    end
+
+    # Emit attribute assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def attribute_assignment(node)
+      dispatch(node.receiver)
+      emit('.')
+      emit(node.name)
+      emit(' ')
+      actual_arguments(node.arguments)
+    end
+
+    # Emit body with taking care on indentation
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def body(node)
+      @indentation+=1
+      node = 
+        case node
+        when Rubinius::AST::EmptyBody
+          node
+        when Rubinius::AST::Block
+          # Hack to correctly indent ensure or rescue
+          noindent = [Rubinius::AST::Ensure, Rubinius::AST::Rescue]
+          if node.array.one? && noindent.include?(node.array.first.class)
+            @indentation-=1
+            dispatch(node)
+            return
+          end
+          node
+        else
+          Rubinius::AST::Block.new(node.line, [node])
+        end
+
+      dispatch(node)
+      nl
+      @indentation-=1 
+    end
+
+    # Emit end keyword
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def kend
+      emit(current_indentation)
+      emit('end')
+    end
+
+    # Emit newline
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def nl
+      emit("\n")
+    end
+
+    # Emit pice of code
+    #
+    # @param [String] code
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def emit(code)
+      @output << code
+    end
+
+    # Return current indentation
+    #
+    # @return [String]
+    #
+    # @api private
+    #
     def current_indentation
       '  ' * @indentation
     end
 
-    def class_def(node, parent)
-      emit "class %s" % node.name.name
+    # Emit dynamic regexp
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dynamic_regex(node)
+      emit('/')
+      emit(node.string)
+      node.array.each do |member|
+        case member
+        when Rubinius::AST::ToString
+          emit('#{')
+          dispatch(member.value)
+          emit('}')
+        when Rubinius::AST::StringLiteral
+          emit(member.string)
+        end
+      end
+      emit('/')
+    end
+
+    # Emit dynamic string body
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dynamic_string_body(node)
+      emit(node.string.inspect[1..-2])
+      node.array.each do |member|
+        case member
+        when Rubinius::AST::ToString
+          emit('#{')
+          dispatch(member.value)
+          emit('}')
+        when Rubinius::AST::StringLiteral
+          emit(member.string.inspect[1..-2])
+        end
+      end
+    end
+
+    # Emit dynamic execute string
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dynamic_execute_string(node)
+      emit('`')
+      dynamic_string_body(node)
+      emit('`')
+    end
+
+    # Emit dynamic string
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dynamic_string(node)
+      emit('"')
+      dynamic_string_body(node)
+      emit('"')
+    end
+
+    # Emit dynamic symbol
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dynamic_symbol(node)
+      emit(':')
+      dynamic_string(node)
+    end
+
+    # Emit singleton class inheritance
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def s_class(node)
+      emit('class << ')
+      dispatch(node.receiver)
+      nl
+      # FIXME: attr_reader missing on Rubinius::AST::SClass
+      scope = node.instance_variable_get(:@body)
+      body = scope.body
+      if body
+        body(body)
+      end
+      kend
+    end
+
+    # Emit to array
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def to_array(node)
+      dispatch(node.value)
+    end
+
+    # Emit multiple assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def multiple_assignment(node)
+      body = node.left.body
+
+      array_body(node.left.body)
+
+      emit(' = ')
+
+      right = node.right
+
+      if node.right.kind_of?(Rubinius::AST::ArrayLiteral)
+        array_body(right.body)
+      else
+        dispatch(right)
+      end
+    end
+
+    # Emit constant assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def constant_assignment(node)
+      dispatch(node.constant)
+      emit(' = ')
+      dispatch(node.value)
+    end
+
+    # Emit negation
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def negate(node)
+      emit('-')
+      dispatch(node.value)
+    end
+
+    # Emit class definition
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def class_def(node)
+      emit('class ')
+
+      dispatch(node.name)
 
       superclass = node.superclass
       unless superclass.is_a?(Rubinius::AST::NilLiteral)
-        emit " < %s" % superclass.name
+        emit ' < '
+        dispatch(superclass)
       end
+      nl
 
-      node.body.lazy_visit self, node, true
+      dispatch(node.body)
 
-      emit "\n"
-      emit "end"
+      kend
     end
 
-    def module_def(node, parent)
-      emit "module %s" % node.name.name
+    # Emit class name
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def class_name(node)
+      emit(node.name)
+    end
 
-      node.body.lazy_visit self, node, true
+    # Emit module name
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def module_name(node)
+      emit(node.name)
+    end
 
-      emit "\n"
-      emit "end"
+    # Emit module definition
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def module_def(node)
+      emit "module "
+      dispatch(node.name)
+      nl
+
+      dispatch(node.body)
+
+      kend
     end
 
-    def empty_body(*)
+    # Emit empty body
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def empty_body(node)
       # do nothing
     end
 
-    def class_scope(node, parent, indent)
-      emit "\n"
-      @indentation += 1 if indent
-      node.body.lazy_visit self, node, indent
-    ensure
-      @indentation -= 1 if indent
+    # Emit class scope
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def class_scope(node)
+      body(node.body)
+    end
+
+    # Emit module scope
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def module_scope(node)
+      body(node.body)
+    end
+
+    # Emit class variable assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def class_variable_assignment(node)
+      if node.value
+        emit("#{node.name} = ")
+        dispatch(node.value)
+      else
+        emit(node.name)
+      end
+    end
+
+    # Emit local variable assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def local_variable_assignment(node)
+      if node.value
+        emit("#{node.name} = ")
+        dispatch(node.value)
+      else
+        emit(node.name)
+      end
+    end
+
+    # Emit class variable
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def class_variable_access(node)
+      emit(node.name)
+    end
+
+    # Emit local variable access
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def local_variable_access(node)
+      emit(node.name)
     end
-    alias module_scope class_scope
 
-    def local_variable_assignment(node, parent)
-      emit "%s = " % node.name
-      node.value.lazy_visit self, node
+    # Emit global variable access
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def global_variable_access(node)
+      emit(node.name)
+    end
+
+    # Emit global variable assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def global_variable_assignment(node)
+      if(node.value)
+        emit("%s = " % node.name)
+        dispatch(node.value)
+      else
+        emit(node.name)
+      end
+    end
+
+    # Emit nref global variable access
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def nth_ref(node)
+      emit("$#{node.which}")
+    end
+
+    # Emit instance variable assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def instance_variable_assignment(node)
+      if(node.value)
+        emit("%s = " % node.name)
+        dispatch(node.value)
+      else
+        emit(node.name)
+      end
     end
 
-    def local_variable_access(node, parent)
-      emit node.name
+    # Emit instance variable access
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def instance_variable_access(node)
+      emit(node.name)
     end
 
-    def instance_variable_assignment(node, parent)
-      emit "%s = " % node.name
-      node.value.lazy_visit self, node
+    # Emit defined check
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def defined(node)
+      emit('defined?(')
+      dispatch(node.expression)
+      emit(')')
     end
 
-    def instance_variable_access(node, parent)
-      emit node.name
+    # Emit fixnum literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def fixnum_literal(node)
+      emit(node.value.to_s)
     end
 
-    def fixnum_literal(node, parent)
-      emit node.value.to_s
+    # Emit float literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def float_literal(node)
+      emit(node.value.to_s)
     end
 
-    def float_literal(node, parent)
-      emit node.value.to_s
+    # Emit string literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def string_literal(node)
+      emit(node.string.inspect)
     end
 
-    def string_literal(node, parent)
-      emit '"' << node.string.to_s << '"'
+    # Emit execute string
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def execute_string(node)
+      emit("`#{node.string.inspect[1..-2]}`")
     end
 
-    def symbol_literal(node, parent)
-      emit ':' << node.value.to_s
+    # Emit symbol literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def symbol_literal(node)
+      emit ":#{node.value.to_s}"
     end
 
-    def true_literal(node, parent)
+    # Emit true literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def true_literal(node)
       emit 'true'
     end
 
-    def false_literal(node, parent)
+    # Emit false literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def false_literal(node)
       emit 'false'
     end
 
-    def nil_literal(node, parent)
+    # Emit nil literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def nil_literal(node)
       emit 'nil'
     end
 
-    def array_literal(node, parent)
-      body = node.body
+    # Emit argumentless super
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def z_super(node)
+      emit('super')
+    end
+
+    # Emit super
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def super(node)
+      z_super(node)
+      arguments(node)
+    end
 
-      emit '['
+    # Emit concat args
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def concat_args(node)
+      emit('[')
+      array_body(node.array.body)
+      emit(', ')
+      emit('*')
+      dispatch(node.rest)
+      emit(']')
+    end
+ 
+    # Emit array body
+    #
+    # @param [Array] body
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def array_body(body)
       body.each_with_index do |node, index|
-        node.lazy_visit self, node
+        dispatch(node)
         emit ', ' unless body.length == index + 1 # last element
       end
-      emit ']'
     end
 
-    def hash_literal(node, parent)
+    # Emit array literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def array_literal(node)
+      emit('[')
+      array_body(node.body)
+      emit(']')
+    end
+
+
+    # Emit emtpy array literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def empty_array(node)
+      emit('[]')
+    end
+
+    # Emit hash literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def hash_literal(node)
       body = node.array.each_slice(2)
 
       emit '{'
       body.each_with_index do |slice, index|
         key, value = slice
 
-        key.lazy_visit self, node
+        dispatch(key)
         emit " => "
-        value.lazy_visit self, node
+        dispatch(value)
 
         emit ', ' unless body.to_a.length == index + 1 # last element
       end
       emit '}'
     end
 
-    def range(node, parent)
-      node.start.lazy_visit self, node
+    # Emit inclusive range literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def range(node)
+      dispatch(node.start)
       emit '..'
-      node.finish.lazy_visit self, node
+      dispatch(node.finish)
     end
 
-    def range_exclude(node, parent)
-      node.start.lazy_visit self, node
+    # Emit exlusive range literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def range_exclude(node)
+      dispatch(node.start)
       emit '...'
-      node.finish.lazy_visit self, node
+      dispatch(node.finish)
     end
 
-    def regex_literal(node, parent)
+    # Emit range literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def regex_literal(node)
       emit '/'
       emit node.source
       emit '/'
     end
 
-    def send(node, parent)
-      unless node.receiver.is_a?(Rubinius::AST::Self)
-        node.receiver.lazy_visit self, node
-        emit '.'
+
+    # Emit receiver
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [true]
+    #   returns true if there is an explicit receiver
+    #
+    # @return [false]
+    #   returns false otherwise
+    #
+    # @api private
+    #
+    def receiver(node)
+      unless node.receiver.is_a?(Rubinius::AST::Self) and node.privately
+        dispatch(node.receiver)
+        true
+      else
+        false
       end
-      emit node.name
+    end
 
-      if node.block
-        emit ' '
-        node.block.lazy_visit self, node if node.block
+    # Emit send literal
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def send(node)
+      if node.name == :'!'
+        emit('!')
+        dispatch(node.receiver)
+        return
+      end
+
+      if receiver(node)
+        emit('.')
+      end
+
+      emit(node.name)
+
+      block = node.block
+
+      if(block)
+        if block.kind_of?(Rubinius::AST::BlockPass)
+          emit('(')
+          block_pass(block)
+          emit(')')
+        else
+          dispatch(block)
+        end
       end
     end
 
-    def send_with_arguments(node, parent)
-      return if process_binary_operator(node, parent) # 1 * 2, a / 3, true && false
+    # Emit arguments
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def arguments(node, open='(', close=')')
+      arguments = node.arguments
+      array, block = arguments.array, node.block
 
+      return if array.empty? and block.nil? and arguments.splat.nil?
+
+      emit(open)
+
+      array_body(array)
+      is_block_pass = block.kind_of?(Rubinius::AST::BlockPass)
+
+      if arguments.splat
+        emit(', ') unless array.empty?
+        dispatch(arguments.splat)
+      end
+
+      if is_block_pass
+        emit(', ') unless array.empty? 
+        block_pass(block)
+      end
+
+      emit(close)
+
+      if block and !is_block_pass
+        dispatch(node.block) 
+      end
+    end
+
+    # Emit self 
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self(node)
+      emit('self')
+    end
+
+    # Emit element reference
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def element_reference(node)
       unless node.receiver.is_a?(Rubinius::AST::Self)
-        node.receiver.lazy_visit self, node
-        emit '.'
+        dispatch(node.receiver)
+      end
+
+      arguments(node,'[',']')
+    end
+
+    # Emit send with arguments 
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def send_with_arguments(node)
+      if node.name == :[]
+        return element_reference(node)
+      end
+      return if process_binary_operator(node)
+
+      if receiver(node)
+        emit('.')
       end
 
-      emit node.name
-      emit '('
-      node.arguments.lazy_visit self, node
-      emit ')'
-      if node.block
-        emit ' '
-        node.block.lazy_visit self, node if node.block
+      emit(node.name)
+
+      arguments(node)
+    end
+
+    # Emit yield
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def yield(node)
+      emit('yield')
+      arguments(node)
+    end
+
+    # Emit receiver case statment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def receiver_case(node)
+      emit('case ')
+      dispatch(node.receiver)
+      nl
+      node.whens.each do |branch|
+        dispatch(branch)
+      end
+      else_body = node.else
+      unless else_body.kind_of?(Rubinius::AST::NilLiteral)
+        emit('else')
+        nl
+        body(else_body)
       end
+      kend
     end
 
-    def actual_arguments(node, parent)
-      body = node.array
-      body.each_with_index do |argument, index|
-        argument.lazy_visit self, parent
-        emit ', ' unless body.length == index + 1 # last element
+    # Emit when
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def when(node)
+      emit('when ')
+      if node.single
+        dispatch(node.single)
+      end
+      if node.conditions
+        array_body(node.conditions.body)
       end
+      if node.splat
+        dispatch(node.splat)
+      end
+      nl
+      body(node.body)
+    end
+
+    # Emit splat when
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def splat_when(node)
+      emit('*')
+      dispatch(node.condition)
     end
 
-    def iter_arguments(node, parent)
+    # Emit splat value
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def splat_value(node)
+      emit('*')
+      dispatch(node.value)
+    end
+
+    # Emit acutal arguments
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def actual_arguments(node)
+      array_body(node.array)
+    end
+
+    # Emit iteration
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def iter(node)
+      emit(' do')
+
+      arguments = node.arguments
+      unless arguments.names.empty?
+        emit(' ')
+        iter_arguments(node.arguments)
+      end
+
+      nl
+      body(node.body)
+
+      kend
+    end
+
+    # Emit iteration arguments for ruby18 mode
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def iter_arguments(node)
       body = if node.prelude == :single
         Array(node.arguments.name)
       else
@@ -198,180 +1285,463 @@ module ToSource
       emit '|'
     end
 
-    def iter(node, parent)
-      emit 'do'
-
-      if node.arguments && node.arguments.arity != -1
-        emit ' '
-        node.arguments.lazy_visit self, parent
+    # Emit iteration arguments for ruby19 mode
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def iter19(node)
+      emit(' do')
+
+      arguments = node.arguments
+      unless arguments.names.empty?
+        emit(' ')
+        formal_arguments_generic(node.arguments,'|','|')
       end
 
-      emit "\n"
-      @indentation += 1
-
-      if node.body.is_a?(Rubinius::AST::Block)
-        node.body.lazy_visit self, parent, true
-      else
-        emit current_indentation
-        node.body.lazy_visit self, parent
-      end
+      nl
+      body(node.body)
 
-      emit "\n"
-      emit 'end'
+      kend
     end
 
-    def block(node, parent, indent=false)
+    # Emit block
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def block(node)
       body = node.array
-      body.each_with_index do |expression, index|
-        emit current_indentation if indent
-        expression.lazy_visit self, parent
-        emit "\n" unless body.length == index + 1 # last element
+      body.each_with_index do |expression,index|
+        emit(current_indentation)
+        dispatch(expression)
+        nl unless body.length == index+1
       end
     end
 
-    def not(node, parent)
-      emit '!'
-      node.value.lazy_visit self, parent
+    # Emit not
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def not(node)
+      emit('!')
+      dispatch(node.value)
     end
 
-    def and(node, parent)
-      node.left.lazy_visit self, node
-      emit ' && '
-      node.right.lazy_visit self, node
+    # Emit and
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def and(node)
+      dispatch(node.left)
+      emit(' && ')
+      dispatch(node.right)
     end
 
-    def or(node, parent)
-      node.left.lazy_visit self, node
-      emit ' || '
-      node.right.lazy_visit self, node
+    # Emit or
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def or(node)
+      dispatch(node.left)
+      emit(' || ')
+      dispatch(node.right)
     end
 
-    def op_assign_and(node, parent)
-      node.left.lazy_visit self, node
-      emit ' && '
-      node.right.lazy_visit self, node
+    # Emit and operation with assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def op_assign_and(node)
+      dispatch(node.left)
+      emit(' && ')
+      dispatch(node.right)
     end
 
-    def op_assign_or(node, parent)
-      node.left.lazy_visit self, node
-      emit ' || '
-      node.right.lazy_visit self, node
+    # Emit or operation with assignment
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def op_assign_or(node)
+      dispatch(node.left)
+      emit(' || ')
+      dispatch(node.right)
     end
-
-    def toplevel_constant(node, parent)
-      emit "::"
-      emit node.name
+    alias_method :op_assign_or19, :op_assign_or
+
+    # Emit toplevel constant 
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def toplevel_constant(node)
+      emit('::')
+      emit(node.name)
     end
 
-    def constant_access(node, parent)
-      emit node.name
+    # Emit constant accesws
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def constant_access(node)
+      emit(node.name)
     end
 
-    def scoped_constant(node, parent)
-      node.parent.lazy_visit self, node
-      emit '::'
-      emit node.name
+    # Emit scoped constant
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def scoped_constant(node)
+      dispatch(node.parent)
+      emit('::')
+      emit(node.name)
+    end
+    alias_method :scoped_class_name, :scoped_constant
+    alias_method :scoped_module_name, :scoped_constant
+
+    # Emit toplevel class name
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def toplevel_class_name(node)
+      emit("::#{node.name}")
     end
 
-    def if(node, parent)
+    # Emit if expression
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def if(node)
       body, else_body = node.body, node.else
+
       keyword = 'if'
 
       if node.body.is_a?(Rubinius::AST::NilLiteral) && !node.else.is_a?(Rubinius::AST::NilLiteral)
-
         body, else_body = else_body, body
         keyword = 'unless'
       end
 
-      emit keyword << ' '
-      node.condition.lazy_visit self, node
-      emit "\n"
+      emit(keyword)
+      emit(' ')
+      dispatch(node.condition)
+      nl
 
-      @indentation += 1
-
-      if body.is_a?(Rubinius::AST::Block)
-        body.lazy_visit self, parent, true
-      else
-        emit current_indentation
-        body.lazy_visit self, parent
-      end
-
-      emit "\n"
+      body(body)
 
       if else_body.is_a?(Rubinius::AST::NilLiteral)
-        emit 'end'
+        kend
         return
       end
 
-      emit "else\n"
+      emit('else')
+      nl
 
-      if else_body.is_a?(Rubinius::AST::Block)
-        else_body.lazy_visit self, parent, true
-      else
-        emit current_indentation
-        else_body.lazy_visit self, parent
-      end
+      body(else_body)
 
-      emit "\n"
-      emit 'end'
+      kend
     end
 
-    def while(node, parent)
+    # Dispatch node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def while(node)
       emit 'while '
-      node.condition.lazy_visit self, node
-      emit "\n"
+      dispatch(node.condition)
+      nl
 
-      @indentation += 1
+      body(node.body)
 
-      if node.body.is_a?(Rubinius::AST::Block)
-        node.body.lazy_visit self, parent, true
-      else
-        emit current_indentation
-        node.body.lazy_visit self, parent
+      kend
+    end
+
+    # Emit until
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def until(node)
+      emit 'until '
+      dispatch(node.condition)
+      nl
+
+      body(node.body)
+
+      kend
+    end
+
+    # Emit formal arguments as shared between ruby18 and ruby19 mode
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def formal_arguments_generic(node,open,close)
+      return if node.names.empty? 
+      required, defaults, splat = node.required, node.defaults, node.splat
+
+      emit(open)
+      emit(required.join(', '))
+
+      empty = required.empty?
+
+      if defaults
+        emit(', ') unless empty
+        dispatch(node.defaults)
+      end
+
+      if splat
+        emit(', ') unless empty
+        emit('*')
+        unless splat == :@unnamed_splat
+          emit(splat)
+        end
       end
 
-      emit "\n"
-      emit "end"
+      if node.block_arg
+        emit(', ') unless empty
+
+        dispatch(node.block_arg)
+      end
+
+      emit(close)
     end
 
-    def until(node, parent)
-      emit 'until '
-      node.condition.lazy_visit self, node
-      emit "\n"
+    # Emit formal arguments for ruby19 and ruby18
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def formal_arguments(node)
+      formal_arguments_generic(node,'(',')')
+    end
+    alias_method :formal_arguments19, :formal_arguments
+
+    # Emit block argument
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def block_argument(node)
+      emit('&')
+      emit(node.name)
+    end
 
-      @indentation += 1
+    # Emit default arguments
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def default_arguments(node)
+      last = node.arguments.length - 1
+      node.arguments.each_with_index do |argument, index|
+        dispatch(argument)
+        emit(',') unless index == last
+      end
+    end
 
-      if node.body.is_a?(Rubinius::AST::Block)
-        node.body.lazy_visit self, parent, true
+    # Emit begin
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def begin(node)
+      emit('begin')
+      nl
+
+      body = node.rescue
+      case body
+      when Rubinius::AST::Rescue
+        # Rescue is reserved keyword
+        __send__(:rescue,body)
+      when Rubinius::AST::Ensure
+        # Ensure is reserved keyword
+        __send__(:ensure,body)
       else
-        emit current_indentation
-        node.body.lazy_visit self, parent
+        body(node.rescue)
       end
 
-      emit "\n"
-      emit "end"
+      kend
     end
 
-    def return(node, parent)
-      emit 'return '
-      node.value.lazy_visit self, parent
+    # Emit define on instances
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def define(node)
+      emit('def ')
+
+      emit(node.name)
+      dispatch(node.arguments)
+      nl
+
+      body(node.body)
+      kend
     end
 
-    private
+    # Emit define on singletons
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def define_singleton(node)
+      emit('def ')
+      dispatch(node.receiver)
+      emit('.')
+      dispatch(node.body)
+    end
 
-    def process_binary_operator(node, parent)
-      operators = %w(+ - * / & | <<).map(&:to_sym)
-      return false unless operators.include?(node.name)
-      return false if node.arguments.array.length != 1
+    # Emit singleton scope
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def define_singleton_scope(node)
+      emit(node.name)
+      dispatch(node.arguments)
+      nl
+      
+      body(node.body)
+
+      kend
+    end
 
-      operand = node.arguments.array[0]
+    # Emit block pass 
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def block_pass(node)
+      emit('&')
+      dispatch(node.body)
+    end
 
-      unless node.receiver.is_a?(Rubinius::AST::Self)
-        node.receiver.lazy_visit self, node
+    # Emit return statement
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def return(node)
+      emit('return')
+      if node.value
+        emit(' ')
+        dispatch(node.value)
       end
+    end
+
+    OPERATORS = %w(
+      + - * / & | && || << >> == 
+      === != <= < <=> > >= =~ !~ ^ 
+      **
+    ).map(&:to_sym).to_set
+
+    # Process binary operator
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [self]
+    #   if node was handled
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def process_binary_operator(node)
+      name = node.name
+      return unless OPERATORS.include?(name)
+      return if node.arguments.array.length != 1
+
+      operand = node.arguments.array[0]
+
+      dispatch(node.receiver)
+
+      emit(" #{name.to_s} ")
+      dispatch(operand)
 
-      emit ' ' << node.name.to_s << ' '
-      operand.lazy_visit self, node
+      self
     end
   end
 end