ripper2ruby 0.0.1

data/lib/ruby/node.rb

@@ -0,0 +1,47 @@
+require 'core_ext/object/meta_class'
+require 'core_ext/object/try'
+require 'ruby/node/composite'
+require 'ruby/node/source'
+require 'ruby/node/traversal'
+require 'ruby/node/conversions'
+
+module Ruby
+  class Node
+    include Comparable
+    include Composite
+    include Source
+    include Traversal
+    include Conversions
+    
+    def row
+      position[0]
+    end
+
+    def column
+      position[1]
+    end
+
+    def length(prolog = false)
+      to_ruby(prolog).length
+    end
+    
+    def nodes
+      []
+    end
+    
+    def all_nodes
+      nodes + nodes.map { |node| node.all_nodes }.flatten
+    end
+    
+    def <=>(other)
+      position <=> (other.respond_to?(:position) ? other.position : other)
+    end
+    
+    protected
+      def update_positions(row, column, offset_column)
+        pos = self.position
+        pos.col += offset_column if pos && self.row == row && self.column > column
+        nodes.each { |c| c.send(:update_positions, row, column, offset_column) }
+      end
+  end
+end

data/lib/ruby/node/composite.rb

@@ -0,0 +1,68 @@
+module Ruby
+  class Node
+    module Composite
+      class Array < ::Array
+        include Composite
+
+        def initialize(objects = [])
+          objects.each { |object| self << object }
+        end
+      
+        def detect
+          each { |element| return element if yield(element) }
+        end
+
+        def <<(object)
+          if object.respond_to?(:parent=)
+            object.parent = self.parent 
+          elsif object.respond_to?(:each)
+            object.each { |o| o.try(:parent=, parent) }
+          end
+          super
+        end
+      
+        def []=(ix, object)
+          object.parent = parent
+          super
+        end
+      
+        def parent=(parent)
+          each { |object| object.try(:parent=, parent) }
+          @parent = parent
+        end
+
+        def +(other)
+          self.dup.tap { |dup| other.each { |object| dup << object } }
+        end
+      end
+
+      def self.included(target)
+        target.class_eval do
+          class << self
+            def child_accessor(*names, &block)
+              names.each do |name|
+                attr_reader name
+                define_method("#{name}=") do |value|
+                  value = Composite::Array.new(value) if value.is_a?(::Array) 
+                  value.parent = self if value
+                  instance_variable_set(:"@#{name}", value)
+                  yield(value) if block_given?
+                end
+              end
+            end
+          end
+        end
+      end
+
+      attr_accessor :parent
+
+      def root?
+        parent.nil?
+      end
+
+      def root
+        root? ? self : parent.root
+      end
+    end
+  end
+end

data/lib/ruby/node/conversions.rb

@@ -0,0 +1,66 @@
+module Ruby
+  module Conversions
+    class << self
+      def included(target)
+        target.send(:extend, ClassMethods)
+      end
+    end
+
+    def to_node(node, position, prolog)
+      node = self.class.from_native(node) unless node.is_a?(Node)
+      node.position = position
+      node.prolog = prolog
+      node
+    end
+    
+    module ClassMethods
+      def from_native(object, position = nil, prolog = nil)
+        from_ruby(object.inspect, position, prolog)
+      end
+      
+      def from_ruby(src, position = nil, prolog = nil)
+        Ripper::RubyBuilder.new(src).parse.statements.first.tap do |node|
+          node.position = position if position
+          node.prolog = prolog if prolog
+        end
+      end
+    end
+    
+    module Token
+      def to_identifier
+        Identifier.new(token, position, prolog)
+      end
+      
+      def to_string_content
+        Ruby::StringContent.new(token, position, prolog)
+      end
+    end
+
+    module List
+      def to_array(ldelim, rdelim)
+        Ruby::Array.new(elements, ldelim, rdelim)
+      end
+    end
+
+    module Statements
+      def to_block(params = nil, ldelim = nil, rdelim = nil)
+        Block.new(elements, params, ldelim, rdelim)
+      end
+
+      def to_named_block(identifier = nil, params = nil, ldelim = nil, rdelim = nil)
+        NamedBlock.new(identifier = nil, elements, params, ldelim, rdelim)
+      end
+
+      def to_chained_block(identifier = nil, blocks = nil, params = nil, ldelim = nil, rdelim = nil)
+        ldelim ||= self.ldelim
+        rdelim ||= self.rdelim
+        identifier ||= self.identifier if respond_to?(:identifier)
+        ChainedBlock.new(identifier, blocks, elements, params, ldelim, rdelim)
+      end
+
+      def to_program(src, filename, end_data)
+        Program.new(src, filename, elements, end_data)
+      end
+    end
+  end
+end

data/lib/ruby/node/position.rb

@@ -0,0 +1,35 @@
+module Ruby
+  class Node
+    class Position
+      include Comparable
+      
+      attr_accessor :row, :col
+      
+      def initialize(row, col)
+        @row = row
+        @col = col
+      end
+      
+      def [](ix)
+        ix == 0 ? row : col
+      end
+    
+      def <=>(other)
+        row < other.row ? -1 : row > other.row ?  1 : col <=> other.col
+      end
+      
+      def ==(other)
+        to_a == other.to_a
+      end
+      alias eql? ==
+      
+      def to_a
+        [row, col]
+      end
+      
+      def inspect
+        to_a.inspect
+      end
+    end
+  end
+end

data/lib/ruby/node/source.rb

@@ -0,0 +1,29 @@
+require 'ruby/node/text'
+
+module Ruby
+  class Node
+    module Source
+      def filename
+        root? ? @filename : root.filename
+      end
+
+      def src(prolog = false)
+        root? ? @src : Ruby::Node::Text.new(root.src).clip(position(prolog), length(prolog)).to_s
+      end
+
+      def lines
+        root.src.split("\n")
+      end
+
+      def line
+        Ruby::Node::Text.new(lines[row]).clip([0, column], length)
+      end
+      
+      def context(options = {})
+        filter = options.has_key?(:highlight) ? options[:highlight] : false
+        line = filter ? self.line.head + filter.highlight(to_ruby) + self.line.tail : nil
+        Ruby::Node::Text::Context.new(lines, row, options[:width] || 2, line).to_s
+      end
+    end
+  end
+end

data/lib/ruby/node/text.rb

@@ -0,0 +1,121 @@
+require 'ruby/node/position'
+
+module Ruby
+  class Node
+    class Text
+      class << self
+        def split(str)
+          str.gsub(/\n/, "\n\000").split(/\000/)
+        end
+      end
+
+      class Context
+        @@context_width = 2
+  
+        class << self
+          def context_width
+            @@context_width
+          end
+  
+          def context_width=(context_width)
+            @@context_width = context_width
+          end
+        end
+        
+        attr_reader :lines, :line, :row, :width
+
+        def initialize(lines, row, width = nil, line = nil)
+          @lines = lines
+          @line = line || lines[row]
+          @row = row
+          @width = width || Context.width
+        end
+
+        def to_s(options = {})
+          (head + [line] + tail).join("\n")
+        end
+
+        protected
+
+          def head
+            min = [0, row - width].max
+            min < row ? lines[min..(row - 1)] : []
+          end
+
+          def tail
+            max = [row + width, lines.size].min
+            max > row ? lines[(row + 1)..max] : []
+          end
+      end
+
+      class Clip
+        attr_reader :lines, :row, :col, :length, :end
+      
+        def initialize(lines, pos, length = nil)
+          @lines = lines.is_a?(::String) ? Text.split(lines) : lines
+          @row, @col = *pos
+          @length = length.nil? ? self.lines.join.length : length
+          init
+        end
+        
+        def end
+          @end ||= Position.new(row, col + self.length)
+        end
+      
+        def end=(position)
+          @end = Position.new(*position)
+        end
+      
+        def head
+          lines[0, row].join + lines[row][0, col]
+        end
+      
+        def tail
+          lines[self.end.row][self.end.col..-1] + lines[(self.end.row + 1)..-1].join
+        end
+      
+        def src
+          lines.join
+        end
+      
+        def to_s
+          @string
+        end
+      
+        protected
+      
+          def init # TODO how to simplify this?
+            @string = lines[row][col, self.length]
+            col = self.length - @string.length
+            row = self.row + 1
+            while (line = lines[row]) && col > 0
+              @string << line[0..(col - 1)]
+              if col - line.length >= 0
+                col -= line.length
+                row += 1
+                self.end = [row, col]
+              else
+                self.end = [row, col]
+                break
+              end
+            end
+          end
+      end
+    
+      attr_reader :str, :sep
+    
+      def initialize(str = '', sep = nil)
+        @str = str
+        @sep = sep || "\n"
+      end
+    
+      def lines
+        @lines ||= Text.split(str)
+      end
+    
+      def clip(pos, length)
+        Clip.new(lines, pos, length)
+      end
+    end
+  end
+end

data/lib/ruby/node/traversal.rb

@@ -0,0 +1,82 @@
+module Ruby
+  class Node
+    module Traversal
+      def select(*args, &block)
+        result = []
+        result << self if matches?(args.dup, &block)
+
+        children = (prolog.try(:elements).to_a || []) + nodes
+        children.flatten.compact.inject(result) do |result, node|
+          result + node.select(*args, &block)
+        end
+      end
+
+      def matches?(args, &block)
+        conditions = args.last.is_a?(::Hash) ? args.pop : {}
+        conditions[:is_a] = args unless args.empty?
+
+        conditions.inject(!conditions.empty?) do |result, (type, value)|
+          result && case type
+          when :is_a
+            has_type?(value)
+          when :class
+            is_instance_of?(value)
+          when :token
+            has_token?(value)
+          when :value
+            has_value?(value)
+          when :pos, :position
+            position?(value)
+          when :right_of
+            right_of?(value)
+          when :left_of
+            left_of?(value)
+          end
+        end && (!block_given? || block.call(self))
+      end
+
+      def has_type?(klass)
+        case klass
+        when ::Array
+          klass.each { |klass| return true if has_type?(klass) } and false
+        else
+          is_a?(klass) # allow to pass a symbol or string, too
+        end
+      end
+
+      def is_instance_of?(klass)
+        case klass
+        when ::Array
+          klass.each { |klass| return true if has_type?(klass) } and false
+        else
+          instance_of?(klass) # allow to pass a symbol or string, too
+        end
+      end
+
+      def has_token?(token)
+        case token
+        when ::Array
+          type.each { |type| return true if has_token?(token) } and false
+        else
+          self.token == token
+        end if respond_to?(:token)
+      end
+
+      def has_value?(value)
+        self.value == value if respond_to?(:value)
+      end
+
+      def position?(pos)
+        position == pos
+      end
+
+      def left_of?(right)
+        right.nil? || self.position < right.position
+      end
+
+      def right_of?(left)
+        left.nil? || left.position < self.position
+      end
+    end
+  end
+end