ripper2ruby 0.0.1

data/lib/ruby/operator.rb

@@ -0,0 +1,49 @@
+require 'ruby/node'
+
+module Ruby
+  class Operator < DelimitedAggregate
+  end
+  
+  class Unary < Operator
+    child_accessor :operator, :operand
+
+    def initialize(operator, operand, ldelim, rdelim)
+      self.operator = operator or raise "operator can not be nil"
+      self.operand = operand
+      super(ldelim, rdelim)
+    end
+    
+    def nodes
+      [operator, ldelim, operand, rdelim].compact
+    end
+  end
+  
+  class Binary < Operator
+    child_accessor :operator, :left, :right
+
+    def initialize(operator, left, right)
+      self.operator = operator or raise "operator can not be nil"
+      self.left = left 
+      self.right = right
+    end
+    
+    def nodes
+      [left, operator, right].compact
+    end
+  end
+  
+  class IfOp < Operator
+    child_accessor :condition, :left, :right, :operators
+
+    def initialize(condition, left, right, operators)
+      self.condition = condition
+      self.left = left
+      self.right = right
+      self.operators = operators
+    end
+    
+    def nodes
+      [[condition, left, right].zip(operators)].flatten.compact
+    end
+  end
+end

data/lib/ruby/params.rb

@@ -0,0 +1,41 @@
+require 'ruby/aggregate'
+require 'ruby/list'
+
+module Ruby
+  class Params < DelimitedList
+    def initialize(params = nil, ldelim = nil, rdelim = nil)
+      params = Array(params).map { |param| param.is_a?(Ruby::Param) ? param : Ruby::Param.new(param) }
+      super
+    end
+    
+    def <<(param)
+      param = Ruby::Param.new(param) unless param.is_a?(Ruby::Param)
+      super
+    end
+  end
+  
+  class Param < DelimitedAggregate
+    child_accessor :param
+    
+    def initialize(param, ldelim = nil)
+      self.param = param
+      super(ldelim)
+    end
+    
+    def nodes
+      [ldelim, param].compact
+    end
+
+    def method_missing(method, *args, &block)
+      param.respond_to?(method) ? param.send(method, *args, &block) : super
+    end
+  end
+  
+  class RescueParams < Params
+    def initialize(types, var, operator)
+      types = Ruby::Array.new(types) if types
+      errors = Ruby::Assoc.new(types, var, operator)
+      super(errors)
+    end
+  end
+end

data/lib/ruby/statements.rb

@@ -0,0 +1,45 @@
+require 'ruby/node'
+
+module Ruby
+  class Statements < DelimitedList
+    include Conversions::Statements
+  end
+  
+  class Program < Statements
+    child_accessor :end_data
+    attr_accessor :filename
+    attr_writer :src
+
+    def initialize(src, filename, statements, end_data)
+      self.src = src
+      self.filename = filename if filename
+      self.end_data = end_data if end_data
+      super(statements)
+    end
+    
+    alias :statements :elements
+    
+    def to_ruby(prolog = false)
+      super(true)
+    end
+    
+    def nodes
+      [super, end_data].flatten.compact
+    end
+    
+    # TODO replace this with Clip?
+    def line_pos(row)
+      (row > 0 ? src.split("\n")[0..(row - 1)].inject(0) { |pos, line| pos + line.length + 1 } : 0)
+    end
+    
+    def replace_src(row, column, length, src)
+      self.src[line_pos(row) + column, length] = src 
+      offset_column = src.length - length
+      update_positions(row, column + length, offset_column)
+    end
+    
+    def save_src
+      File.open(filename, 'w+') { |f| f.write(src) }
+    end
+  end
+end

data/lib/ruby/string.rb

@@ -0,0 +1,40 @@
+require 'ruby/node'
+
+module Ruby
+  class StringConcat < List
+  end
+  
+  class String < DelimitedList
+    def initialize(contents = nil, ldelim = nil, rdelim = nil)
+      super(contents, ldelim, rdelim)
+    end
+    
+    def value
+      map { |content| content.value }.join
+    end
+    
+    def dynamic?
+      !elements.inject(true) { |result, element| result && element.respond_to?(:value) }
+    end
+    
+    def respond_to?(method)
+      return false if method.to_sym == :value && dynamic?
+      super
+    end
+  end
+  
+  class Heredoc < String
+  end
+
+  class StringContent < Token
+    def value
+      token
+    end
+  end
+  
+  class Regexp < String
+  end
+  
+  class ExecutableString < String
+  end
+end

data/lib/ruby/symbol.rb

@@ -0,0 +1,27 @@
+require 'ruby/aggregate'
+require 'ruby/string'
+
+module Ruby
+  class Symbol < DelimitedAggregate
+    child_accessor :identifier
+    
+    def initialize(identifier, ldelim)
+      self.identifier = identifier
+      super(ldelim)
+    end
+    
+    def value
+      identifier.token.to_sym
+    end
+    
+    def nodes
+      [ldelim, identifier].compact
+    end
+  end
+  
+  class DynaSymbol < String
+    def value
+      super.to_sym
+    end
+  end
+end

data/lib/ruby/token.rb

@@ -0,0 +1,51 @@
+require 'ruby/node'
+
+module Ruby
+  class Token < Node
+    include Conversions::Token
+
+    attr_accessor :token, :position, :prolog
+
+    def initialize(token = '', position = nil, prolog = nil)
+      self.token = token
+      self.position = position if position
+      self.prolog = prolog || Prolog.new
+    end
+
+    def position(prolog = false)
+      (self.prolog.try(:position) if prolog) || @position
+    end
+
+    def position=(position)
+      @position = position.dup if position
+    end
+
+    def to_s
+      token.to_s
+    end
+
+    def to_ruby(prolog = false)
+      (prolog && self.prolog.try(:to_ruby, prolog) || '') + token.to_s
+    end
+  end
+
+  class Whitespace < Token
+    def empty?
+      token.empty?
+    end
+
+    def inspect
+      token.inspect
+    end
+  end
+
+  class Keyword < Token
+  end
+
+  class HeredocBegin < Token
+    attr_accessor :heredoc
+  end
+
+  class Identifier < Token
+  end
+end

data/lib/ruby/while.rb

@@ -0,0 +1,32 @@
+require 'ruby/node'
+
+module Ruby
+  class While < NamedBlock
+    child_accessor :expression
+    
+    def initialize(identifier, expression, statements, ldelim = nil, rdelim = nil)
+      self.expression = expression
+      super(identifier, statements, nil, ldelim, rdelim)
+    end
+      
+    def nodes
+      [identifier, expression, ldelim, elements, rdelim].flatten.compact
+    end
+  end
+  
+  class WhileMod < NamedBlock
+    child_accessor :expression
+    
+    def initialize(identifier, expression, statements)
+      self.expression = expression
+      super(identifier, statements)
+    end
+      
+    def nodes
+      [elements, identifier, expression].flatten.compact
+    end
+  end
+  
+  class Until < While; end
+  class UntilMod < WhileMod; end
+end

data/test/all.rb

@@ -0,0 +1,3 @@
+files = Dir[File.dirname(__FILE__) + '/**/*_test.rb']
+files.reject! { |f| f.index('lib_test.rb') }
+files.each { |file| require file }

data/test/builder/stack_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class StackTest < Test::Unit::TestCase
+  def setup
+    @builder = Ripper::RubyBuilder.new('')
+  end
+  
+  def push(*types)
+    types.each { |type| @builder.send(:push, Array(type)) }
+  end
+  
+  def stack
+    @builder.stack
+  end
+
+  # define_method "test pop: pops off elements until it finds a token with the requested type" do
+  #   push(:@lbrace, :@comma, :@comma, :@rbrace)
+  # 
+  #   assert_equal :@rbrace, @builder.send(:pop, :@rbrace).first.type
+  #   assert !@builder.stack.empty?
+  #   assert @builder.send(:pop, :foo).empty?
+  # 
+  #   commas = @builder.send(:pop, :@comma)
+  #   assert_equal 2, commas.length
+  #   assert_equal :@comma, commas[0].type
+  #   assert_equal :@comma, commas[1].type
+  # 
+  #   assert_equal :@lbrace, @builder.send(:pop, :@lbrace).first.type
+  #   assert @builder.stack.empty?
+  #   assert @builder.send(:pop, :foo).empty?
+  # end
+  # 
+  # define_method "test pop: leaves the stack untouched if it does not find a token with the requested type" do
+  #   push(:@lbrace, :@comma, :@comma, :@rbrace)
+  # 
+  #   assert @builder.send(:pop, :foo).empty?
+  #   assert !@builder.stack.empty?
+  #   assert !@builder.send(:pop, :@rbrace).empty?
+  # end
+  # 
+  # define_method "test push: pushes non-opening tokens directly to the stack" do
+  #   push(:@rbrace)
+  #   assert_equal :@rbrace, stack.last.type
+  # end
+  
+  # define_method "test push: opening tokens are queued and then pushed together with the next token" do
+  #   push([:@sp, ' '], [:@sp, ' '], :@lbrace)
+  #   assert_equal nil, stack.last
+  #   assert_equal :@lbrace, stack.queue.last.type
+  #   assert_equal nil,  @builder.send(:pop_context)
+  #   
+  #   push(:@rbrace)
+  #   assert_equal :@rbrace, stack[1].type
+  #   assert_equal :@lbrace, stack[0].type
+  #   assert_equal '  ', stack[0].context.whitespace.token
+  #   assert_equal nil,  stack.queue.last
+  # end
+  # 
+  # define_method "test push: context can be obtained by identifiers, keywords, etc." do
+  #   push([:@sp, ' '])
+  #   context = @builder.send(:pop_context)
+  #   assert_not_nil context.whitespace.token
+  #   assert_equal ' ',  context.whitespace.token
+  # end
+end
+
+

data/test/builder/text_test.rb

@@ -0,0 +1,118 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'ruby/node/text'
+
+class TextClipTest < Test::Unit::TestCase
+  include Ruby
+
+  def setup
+    @lines = Node::Text.split("abcd\nbbbb\ncccc\ndddd\neeee\nffff")
+  end
+
+  define_method :"test clip.to_s (1)" do
+    assert_equal "ab", Node::Text::Clip.new(@lines, [0, 0], 2).to_s
+  end
+
+  define_method :"test clip.to_s (2)" do
+    assert_equal "bc", Node::Text::Clip.new(@lines, [0, 1], 2).to_s
+  end
+
+  define_method :"test clip.to_s (3)" do
+    assert_equal "cd", Node::Text::Clip.new(@lines, [0, 2], 2).to_s
+  end
+
+  define_method :"test clip.to_s (4)" do
+    assert_equal "abcd\nbbbb\n", Node::Text::Clip.new(@lines, [0, 0], 10).to_s
+  end
+
+  define_method :"test clip.to_s (5)" do
+    assert_equal "abcd\nbbbb\ncc", Node::Text::Clip.new(@lines, [0, 0], 12).to_s
+  end
+
+  define_method :"test clip.to_s (6)" do
+    assert_equal "cc\ndddd\nee", Node::Text::Clip.new(@lines, [2, 2], 10).to_s
+  end
+
+  define_method :"test clip.head" do
+    assert_equal "abcd\nbbbb\ncc", Node::Text::Clip.new(@lines, [2, 2], 10).head
+  end
+
+  define_method :"test clip.tail (1)" do
+    assert_equal "b\ncccc\ndddd\neeee\nffff", Node::Text::Clip.new(@lines, [0, 2], 6).tail
+  end
+
+  define_method :"test clip.tail (2)" do
+    assert_equal "fff", Node::Text::Clip.new(@lines, [4, 2], 4).tail
+  end
+
+  define_method :"test clip.end (1)" do
+    assert_equal [0, 2], Node::Text::Clip.new(@lines, [0, 0], 2).end.to_a
+  end
+
+  define_method :"test clip.end (2)" do
+    assert_equal [2, 0], Node::Text::Clip.new(@lines, [0, 0], 10).end.to_a
+  end
+
+  define_method :"test clip.end (3)" do
+    assert_equal [3, 2], Node::Text::Clip.new(@lines, [1, 2], 10).end.to_a
+  end
+
+  define_method :"test clip.end (4)" do
+    assert_equal [5, 1], Node::Text::Clip.new(@lines, [4, 2], 4).end.to_a
+  end
+end
+
+class TextTest < Test::Unit::TestCase
+  include Ruby
+
+  def setup
+    @text = Node::Text.new("aa\nbb\ncc\ndd\nee\nff")
+  end
+
+  define_method :"test lines returns an array of lines" do
+    assert_equal ::Array, @text.lines.class
+    assert_equal 6, @text.lines.size
+  end
+
+  define_method :"test clip returns a clip" do
+    assert_equal Node::Text::Clip, @text.clip([1, 1], 6).class
+    assert_equal "b\ncc\nd", @text.clip([1, 1], 6).to_s
+  end
+end
+
+class TextNodeTest < Test::Unit::TestCase
+  include TestHelper
+
+  define_method :"test nodes yield expected src clips" do
+    src = " t(1, 2)\n t(3); t(4)\n t(5)"
+    calls = build(src)
+  
+    assert_equal 't(1, 2)', calls[0].to_ruby
+    assert_equal 't(1, 2)', calls[0].src
+  
+    assert_equal 't(3)', calls[1].to_ruby
+    assert_equal 't(3)', calls[1].src
+  
+    assert_equal 't(4)', calls[2].to_ruby
+    assert_equal 't(4)', calls[2].src
+  
+    assert_equal 't(5)', calls[3].to_ruby
+    assert_equal 't(5)', calls[3].src
+  end
+
+  define_method :"test nodes yield expected src clips, including whitespace" do
+    src = " t(1, 2)\n t(3); t(4)\n t(5)"
+    calls = build(src)
+
+    assert_equal " t(1, 2)", calls[0].to_ruby(true)
+    assert_equal " t(1, 2)", calls[0].src(true)
+    
+    assert_equal "\n t(3)", calls[1].to_ruby(true)
+    assert_equal "\n t(3)", calls[1].src(true)
+    
+    assert_equal "; t(4)", calls[2].to_ruby(true)
+    assert_equal "; t(4)", calls[2].src(true)
+    
+    assert_equal "\n t(5)", calls[3].to_ruby(true)
+    assert_equal "\n t(5)", calls[3].src(true)
+  end
+end