ripper2ruby 0.0.1

data/lib/ruby/args.rb

@@ -0,0 +1,36 @@
+require 'ruby/aggregate'
+require 'ruby/list'
+require 'ruby/alternation/args'
+
+module Ruby
+  class ArgsList < DelimitedList
+    include Alternation::ArgsList
+
+    def initialize(args = nil, ldelim = nil, rdelim = nil)
+      args = Array(args).map { |arg| arg.is_a?(Ruby::Arg) ? arg : Ruby::Arg.new(arg) }
+      super
+    end
+    
+    def <<(arg)
+      arg = Ruby::Arg.new(arg) unless arg.is_a?(Ruby::Arg)
+      super
+    end
+  end
+  
+  class Arg < DelimitedAggregate
+    child_accessor :arg
+    
+    def initialize(arg, ldelim = nil)
+      self.arg = arg
+      super(ldelim)
+    end
+    
+    def nodes
+      [ldelim, arg].compact
+    end
+
+    def method_missing(method, *args, &block)
+      arg.respond_to?(method) ? arg.send(method, *args, &block) : super
+    end
+  end
+end

data/lib/ruby/array.rb

@@ -0,0 +1,27 @@
+require 'ruby/list'
+
+module Ruby
+  class Array < DelimitedList
+    def value
+      elements.map { |element| element.value }
+    end
+  end
+  
+  class Range < Aggregate
+    child_accessor :left, :operator, :right
+    
+    def initialize(left, operator, right)
+      self.left = left
+      self.operator = operator
+      self.right = right
+    end
+    
+    def value
+      operator.token == '..' ? (left.value..right.value) : (left.value...right.value)
+    end
+    
+    def nodes
+      [left, operator, right]
+    end
+  end
+end

data/lib/ruby/assignment.rb

@@ -0,0 +1,32 @@
+require 'ruby/node'
+
+module Ruby
+  class Assignment < Aggregate
+    child_accessor :left, :right, :operator
+
+    def initialize(left, right, operator)
+      self.left = left
+      self.right = right
+      self.operator = operator
+    end
+    
+    def nodes
+      [left, operator, right].compact
+    end
+  end
+
+  class MultiAssignment < DelimitedList
+    attr_accessor :kind
+    child_accessor :splat
+
+    def initialize(kind, elements = [], ldelim = nil, rdelim = nil, splat = nil)
+      self.kind = kind
+      self.splat = splat
+      super(elements, ldelim, rdelim)
+    end
+    
+    def nodes
+      [ldelim, splat, elements, rdelim].flatten.compact
+    end
+  end
+end

data/lib/ruby/assoc.rb

@@ -0,0 +1,17 @@
+require 'ruby/node'
+
+module Ruby
+  class Assoc < Aggregate
+    child_accessor :key, :value, :operator
+    
+    def initialize(key, value, operator)
+      self.key = key
+      self.value = value
+      self.operator = operator
+    end
+    
+    def nodes
+      [key, operator, value].compact
+    end
+  end
+end

data/lib/ruby/block.rb

@@ -0,0 +1,42 @@
+require 'ruby/statements'
+
+module Ruby
+  class Block < Statements
+    child_accessor :params
+    
+    def initialize(statements, params = nil, ldelim = nil, rdelim = nil)
+      self.params = params
+      super(statements, ldelim, rdelim)
+    end
+    
+    def nodes
+      [ldelim, params, elements, rdelim].flatten.compact
+    end
+  end
+  
+  class NamedBlock < Block
+    child_accessor :identifier
+    
+    def initialize(identifier, statements, params = nil, ldelim = nil, rdelim = nil)
+      self.identifier = identifier
+      super(statements, params, ldelim, rdelim)
+    end
+    
+    def nodes
+      [identifier, super].flatten.compact
+    end
+  end
+  
+  class ChainedBlock < NamedBlock
+    child_accessor :blocks
+
+    def initialize(identifier, blocks, statements, params = nil, ldelim = nil, rdelim = nil)
+      self.blocks = Array(blocks) || []
+      super(identifier, statements, params, ldelim, rdelim)
+    end
+    
+    def nodes
+      [identifier, params, ldelim, elements, blocks, rdelim].flatten.compact
+    end
+  end
+end

data/lib/ruby/call.rb

@@ -0,0 +1,34 @@
+require 'ruby/args'
+
+module Ruby
+  class Call < Aggregate
+    child_accessor :identifier, :separator, :target, :arguments, :block
+
+    def initialize(target, separator, identifier, arguments = nil, block = nil)
+      self.target = target
+      self.separator = separator
+      self.identifier = identifier
+      self.arguments = arguments
+      self.block = block
+    end
+
+    def token
+      identifier.token
+    end
+
+    def nodes
+      [target, separator, identifier, arguments, block].flatten.compact
+    end
+  end
+
+  class Alias < Call
+    def initialize(identifier, arguments)
+      self.identifier = identifier
+      self.arguments = arguments
+    end
+
+    def nodes
+      [identifier, arguments].flatten
+    end
+  end
+end

data/lib/ruby/case.rb

@@ -0,0 +1,30 @@
+require 'ruby/node'
+
+module Ruby
+  class Case < NamedAggregate 
+    child_accessor :expression, :block
+    
+    def initialize(identifier, expression, block, rdelim)
+      self.expression = expression
+      self.block = block
+      super(identifier, nil, rdelim)
+    end
+      
+    def nodes
+      [identifier, expression, block, rdelim].compact
+    end
+  end
+
+  class When < ChainedBlock 
+    child_accessor :expression
+    
+    def initialize(identifier, expression, statements, ldelim = nil, block = nil)
+      self.expression = expression
+      super(identifier, [block], statements, nil, ldelim)
+    end
+      
+    def nodes
+      [identifier, expression, ldelim, elements, blocks, rdelim].flatten.compact
+    end
+  end
+end

data/lib/ruby/const.rb

@@ -0,0 +1,49 @@
+require 'ruby/aggregate'
+
+module Ruby
+  class Const < DelimitedAggregate
+    child_accessor :identifier, :namespace
+    
+    def initialize(token = nil, position = nil, prolog = nil, ldelim = nil)
+      self.identifier = Ruby::Identifier.new(token, position, prolog)
+      super(ldelim)
+    end
+    
+    def position(*)
+      super
+    end
+    
+    def nodes
+      [namespace, ldelim, identifier].compact
+    end
+  end
+  
+  class Module < DelimitedAggregate
+    child_accessor :const, :body
+
+    def initialize(const, body, ldelim, rdelim)
+      self.const = const
+      self.body = body
+      super(ldelim, rdelim)
+    end
+
+    def nodes
+      [ldelim, const, body, rdelim].compact
+    end
+  end
+
+  class Class < NamedAggregate
+    child_accessor :operator, :super_class, :body
+
+    def initialize(const, operator, super_class, body, ldelim, rdelim)
+      self.operator = operator
+      self.super_class = super_class
+      self.body = body
+      super(const, ldelim, rdelim)
+    end
+
+    def nodes
+      [ldelim, identifier, operator, super_class, body, rdelim].compact
+    end
+  end
+end

data/lib/ruby/for.rb

@@ -0,0 +1,18 @@
+require 'ruby/statements'
+
+module Ruby
+  class For < NamedBlock
+    child_accessor :variable, :operator, :range
+
+    def initialize(identifier, variable, operator, range, statements, ldelim = nil, rdelim = nil)
+      self.variable = variable
+      self.operator = operator
+      self.range = range
+      super(identifier, statements, nil, ldelim, rdelim)
+    end
+      
+    def nodes
+      [identifier, variable, operator, range, ldelim, elements, rdelim].flatten.compact
+    end
+  end
+end

data/lib/ruby/hash.rb

@@ -0,0 +1,14 @@
+require 'ruby/assoc'
+require 'ruby/alternation/hash'
+
+module Ruby
+  class Hash < DelimitedList
+    include Alternation::Hash
+    
+    def value
+      code = to_ruby(false)
+      code = "{#{code}}" unless ldelim
+      eval(code) rescue {}
+    end
+  end
+end

data/lib/ruby/if.rb

@@ -0,0 +1,35 @@
+require 'ruby/node'
+
+module Ruby
+  class If < ChainedBlock 
+    child_accessor :expression, :else_block
+
+    def initialize(identifier, expression, statements = nil, ldelim = nil, rdelim = nil, else_block = nil)
+      self.expression = expression
+      super(identifier, [else_block], statements, nil, ldelim, rdelim)
+    end
+      
+    def nodes
+      [identifier, expression, ldelim, elements, blocks, rdelim].flatten.compact
+    end
+  end
+  
+  class Unless < If; end
+  class Else < NamedBlock; end
+
+  class IfMod < 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 UnlessMod < IfMod; end
+  class RescueMod < IfMod; end
+end

data/lib/ruby/list.rb

@@ -0,0 +1,40 @@
+require 'ruby/node'
+require 'ruby/alternation/list'
+
+module Ruby
+  class List < Aggregate
+    include Conversions::List
+    include Alternation::List
+    
+    child_accessor :elements
+    
+    def initialize(elements = nil)
+      self.elements = Array(elements)
+    end
+    
+    def nodes
+      elements
+    end
+    
+    def method_missing(method, *args, &block)
+      elements.respond_to?(method) ? elements.send(method, *args, &block) : super
+    end
+  end
+  
+  class DelimitedList < List
+    child_accessor :ldelim, :rdelim
+    
+    def initialize(elements = nil, ldelim = nil, rdelim = nil)
+      self.ldelim = ldelim
+      self.rdelim = rdelim
+      super(elements)
+    end
+    
+    def nodes
+      ([ldelim] + super + [rdelim]).flatten.compact
+    end
+  end
+
+  class Prolog < List
+  end
+end

data/lib/ruby/literal.rb

@@ -0,0 +1,45 @@
+require 'ruby/token'
+
+module Ruby
+  class Nil < Token
+    def value
+      nil
+    end
+  end
+  
+  class True < Token
+    def value
+      true
+    end
+  end
+  
+  class False < Token
+    def value
+      false
+    end
+  end
+  
+  class Integer < Token
+    def value
+      token.to_i
+    end
+  end
+
+  class Float < Token
+    def value
+      token.to_f
+    end
+  end
+
+  class Char < Token
+    def value
+      token[1]
+    end
+  end
+  
+  class Label < Token
+    def value
+      token.gsub(':').to_sym
+    end
+  end
+end

data/lib/ruby/method.rb

@@ -0,0 +1,19 @@
+require 'ruby/node'
+
+module Ruby
+  class Method < NamedAggregate
+    child_accessor :target, :separator, :params, :block # TODO rename block to body
+
+    def initialize(target, separator, identifier, params, block, ldelim, rdelim)
+      self.target = target
+      self.separator = separator
+      self.params = params
+      self.block = block
+      super(identifier, ldelim, rdelim)
+    end
+    
+    def nodes
+      [ldelim, target, separator, identifier, params, block, rdelim].compact
+    end
+  end
+end