to_source 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rbx
+*.rbc

data/.rvmrc

@@ -0,0 +1 @@
+rvm use rbx-head@to_source --create

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+  - rbx-18mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in to_source.gemspec
+gemspec
+gem 'rake'

data/Rakefile

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

data/Readme.md

@@ -0,0 +1,31 @@
+# to_source [![Build Status](https://secure.travis-ci.org/txus/to_source.png)](http://travis-ci.org/txus/to_source)
+
+to_source is a little Rubinius gem that enables Abstract Syntax Tree nodes to
+transform themselves into source code. It's the reverse of Rubinius' builtin
+`#to_ast` method. See for yourself:
+
+    #!/bin/rbx
+    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"
+
+## Installing
+
+to_source needs Rubinius 2.0 to run, in either 1.8 or 1.9 mode.
+
+Put this in your Gemfile:
+
+    gem 'to_source'
+
+And just call `#to_source` in any AST node!
+
+## Who's this
+
+This was made by [Josep M. Bach (Txus)](http://txustice.me) under the MIT
+license. I'm [@txustice](http://twitter.com/txustice) on twitter (where you
+should probably follow me!).

data/lib/to_source/core_ext/node.rb

@@ -0,0 +1,19 @@
+module Rubinius
+  module AST
+    class Node
+      # Public: Works like #visit, but it doesn't visit the children just yet;
+      # instead, lets the visitor decide when and how to do it.
+      #
+      # visitor - The visitor object. It must respond to methods named after the
+      #           node names.
+      #
+      # Returns nothing.
+      def lazy_visit(visitor, parent=nil, indent=false)
+        args = [self.node_name, self, parent]
+        args.push true if indent
+
+        visitor.__send__ *args
+      end
+    end
+  end
+end

data/lib/to_source/version.rb

@@ -0,0 +1,3 @@
+module ToSource
+  VERSION = "0.0.1"
+end

data/lib/to_source/visitor.rb

@@ -0,0 +1,237 @@
+module ToSource
+  class Visitor
+    def initialize
+      @output = []
+      @indentation = 0
+    end
+
+    def emit(code)
+      @output.push code
+    end
+
+    def output
+      @output.join
+    end
+
+    def current_indentation
+      '  ' * @indentation
+    end
+
+    def local_variable_assignment(node, parent)
+      emit "%s = " % node.name
+      node.value.lazy_visit self, node
+    end
+
+    def local_variable_access(node, parent)
+      emit node.name
+    end
+
+    def fixnum_literal(node, parent)
+      emit node.value.to_s
+    end
+
+    def float_literal(node, parent)
+      emit node.value.to_s
+    end
+
+    def string_literal(node, parent)
+      emit '"' << node.string.to_s << '"'
+    end
+
+    def symbol_literal(node, parent)
+      emit ':' << node.value.to_s
+    end
+
+    def true_literal(node, parent)
+      emit 'true'
+    end
+
+    def false_literal(node, parent)
+      emit 'false'
+    end
+
+    def nil_literal(node, parent)
+      emit 'nil'
+    end
+
+    def array_literal(node, parent)
+      body = node.body
+
+      emit '['
+      body.each_with_index do |node, index|
+        node.lazy_visit self, node
+        emit ', ' unless body.length == index + 1 # last element
+      end
+      emit ']'
+    end
+
+    def hash_literal(node, parent)
+      body = node.array.each_slice(2)
+
+      emit '{'
+      body.each_with_index do |slice, index|
+        key, value = slice
+
+        key.lazy_visit self, node
+        emit " => "
+        value.lazy_visit self, node
+
+        emit ', ' unless body.to_a.length == index + 1 # last element
+      end
+      emit '}'
+    end
+
+    def range(node, parent)
+      node.start.lazy_visit self, node
+      emit '..'
+      node.finish.lazy_visit self, node
+    end
+
+    def regex_literal(node, parent)
+      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 '.'
+      end
+      emit node.name
+
+      if node.block
+        emit ' '
+        node.block.lazy_visit self, node if node.block
+      end
+    end
+
+    def send_with_arguments(node, parent)
+      return if process_binary_operator(node, parent) # 1 * 2, a / 3, true && false
+
+      unless node.receiver.is_a?(Rubinius::AST::Self)
+        node.receiver.lazy_visit self, 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
+      end
+    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
+      end
+    end
+
+    def iter_arguments(node, parent)
+      body = if node.prelude == :single
+        Array(node.arguments.name)
+      else
+        node.arguments.left.body.map(&:name)
+      end
+
+      emit '|'
+      body.each_with_index do |argument, index|
+        emit argument.to_s
+        emit ', ' unless body.length == index + 1 # last element
+      end
+      emit '|'
+    end
+
+    def iter(node, parent)
+      emit 'do'
+
+      if node.arguments && node.arguments.arity != -1
+        emit ' '
+        node.arguments.lazy_visit self, parent
+      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
+
+      emit "\n"
+      emit 'end'
+    end
+
+    def block(node, parent, indent=false)
+      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
+      end
+    end
+
+    def not(node, parent)
+      emit '!'
+      node.value.lazy_visit self, parent
+    end
+
+    def and(node, parent)
+      node.left.lazy_visit self, node
+      emit ' && '
+      node.right.lazy_visit self, node
+    end
+
+    def or(node, parent)
+      node.left.lazy_visit self, node
+      emit ' || '
+      node.right.lazy_visit self, node
+    end
+
+    def op_assign_and(node, parent)
+      node.left.lazy_visit self, node
+      emit ' && '
+      node.right.lazy_visit self, node
+    end
+
+    def op_assign_or(node, parent)
+      node.left.lazy_visit self, node
+      emit ' || '
+      node.right.lazy_visit self, node
+    end
+
+    def constant_access(node, parent)
+      emit node.name
+    end
+
+    def scoped_constant(node, parent)
+      node.parent.lazy_visit self, node
+      emit '::'
+      emit node.name
+    end
+
+    private
+
+    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
+
+      operand = node.arguments.array[0]
+
+      unless node.receiver.is_a?(Rubinius::AST::Self)
+        node.receiver.lazy_visit self, node
+      end
+
+      emit ' ' << node.name.to_s << ' '
+      operand.lazy_visit self, node
+    end
+  end
+end

data/lib/to_source.rb

@@ -0,0 +1,16 @@
+require "to_source/version"
+require "to_source/core_ext/node"
+require "to_source/visitor"
+
+module ToSource
+  # Public: Converts the node back to its original source code.
+  #
+  # Returns the String output.
+  def to_source
+    visitor = Visitor.new
+    lazy_visit(visitor)
+    visitor.output
+  end
+end
+
+Rubinius::AST::Node.send :include, ToSource

data/test/to_source/visitor_test.rb

@@ -0,0 +1,126 @@
+require 'test/unit'
+require 'to_source'
+
+module ToSource
+  class VisitorTest < Test::Unit::TestCase
+    def visit(code)
+      code.to_ast.to_source
+    end
+
+    def assert_source(code)
+      assert_equal code, visit(code)
+    end
+
+    def assert_converts(expected, code)
+      assert_equal expected, visit(code)
+    end
+
+    def test_local_assignment
+      assert_source "foo = 1"
+    end
+
+    def test_local_access
+      assert_source "foo = 1\nfoo"
+    end
+
+    def test_constant_access
+      assert_source "Rubinius"
+    end
+
+    def test_scoped_constant_access
+      assert_source "Rubinius::Debugger"
+    end
+
+    def test_fixnum_literal
+      assert_source "1"
+    end
+
+    def test_float_literal
+      assert_source "1.0"
+    end
+
+    def test_string_literal
+      assert_source '"foo"'
+    end
+
+    def test_symbol_literal
+      assert_source ':foo'
+    end
+
+    def test_true_literal
+      assert_source 'true'
+    end
+
+    def test_false_literal
+      assert_source 'false'
+    end
+
+    def test_nil_literal
+      assert_source 'nil'
+    end
+
+    def test_array_literal
+      assert_source '[1, 2, 3]'
+    end
+
+    def test_hash_literal
+      assert_source '{:answer => 42, :bar => :baz}'
+    end
+
+    def test_range
+      assert_source '20..34'
+    end
+
+    def test_regex
+      assert_source '/.*/'
+    end
+
+    def test_send
+      assert_source 'foo.bar'
+    end
+
+    def test_send_with_arguments
+      assert_converts 'foo.bar(:baz, :yeah)', 'foo.bar :baz, :yeah'
+    end
+
+    def test_send_with_arguments_and_empty_block
+      assert_converts "foo.bar(:baz, :yeah) do\n  nil\nend", "foo.bar(:baz, :yeah) do\nend"
+    end
+
+    def test_send_with_arguments_and_block_with_one_argument
+      assert_source "foo.bar(:baz, :yeah) do |a|\n  3\n  4\nend"
+    end
+
+    def test_send_with_arguments_and_block_with_arguments
+      assert_source "foo.bar(:baz, :yeah) do |a, b|\n  3\n  4\nend"
+    end
+
+    def test_lambda
+      assert_source "lambda do |a, b|\n  a\nend"
+    end
+
+    def test_proc
+      assert_source "Proc.new do\n  a\nend"
+    end
+
+    def test_binary_operators
+      %w(+ - * / & | && || <<).each do |operator|
+        assert_source "1 #{operator} 2"
+      end
+    end
+
+    def test_expands_binary_equal
+      assert_converts "a = a + 2", "a += 2"
+      assert_converts "a = a - 2", "a -= 2"
+      assert_converts "a = a * 2", "a *= 2"
+      assert_converts "a = a / 2", "a /= 2"
+      assert_converts "a && a = 2", "a &&= 2"
+      assert_converts "a || a = 2", "a ||= 2"
+    end
+
+    def test_unary_operators
+      assert_source "!1"
+      assert_source "!!1"
+    end
+  end
+end

data/to_source.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "to_source/version"
+
+Gem::Specification.new do |s|
+  s.name        = "to_source"
+  s.version     = ToSource::VERSION
+  s.authors     = ["Josep M. Bach"]
+  s.email       = ["josep.m.bach@gmail.com"]
+  s.homepage    = "http://github.com/txus/to_source"
+  s.summary     = %q{Transform your Rubinius AST nodes back to source code. Reverse parsing!}
+  s.description = %q{Transform your Rubinius AST nodes back to source code. Reverse parsing!}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: to_source
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors:
+- Josep M. Bach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-23 00:00:00.000000000 Z
+dependencies: []
+description: Transform your Rubinius AST nodes back to source code. Reverse parsing!
+email:
+- josep.m.bach@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Rakefile
+- Readme.md
+- lib/to_source.rb
+- lib/to_source/core_ext/node.rb
+- lib/to_source/version.rb
+- lib/to_source/visitor.rb
+- test/to_source/visitor_test.rb
+- to_source.gemspec
+homepage: http://github.com/txus/to_source
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: Transform your Rubinius AST nodes back to source code. Reverse parsing!
+test_files:
+- test/to_source/visitor_test.rb