to_source 0.2.9 → 0.2.11

data/lib/to_source/emitter/execute_string.rb

@@ -0,0 +1,13 @@
+module ToSource
+  class Emitter
+    class ExecuteString < self
+
+      handle(Rubinius::AST::ExecuteString)
+
+      def dispatch
+        emit("`#{node.string}`")
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/formal_arguments.rb

@@ -0,0 +1,120 @@
+module ToSource
+  class Emitter
+    class FormalArguments < self
+
+    private
+
+      def any?
+        required? or defaults? or splat? or block_arg?
+      end
+
+      def required
+        arguments.required
+      end
+
+      def required?
+        required.any?
+      end
+
+      def defaults
+        arguments.defaults
+      end
+
+      def defaults?
+        !!defaults
+      end
+
+      def splat
+        arguments.splat
+      end
+
+      def splat?
+        !!splat
+      end
+
+      def block_arg
+        arguments.block_arg
+      end
+
+      def block_arg?
+        !!block_arg
+      end
+
+      def emit_required
+        array = required
+        max = array.length - 1
+        array.each_with_index do |member, index|
+          if member.kind_of?(Rubinius::AST::Node)
+            visit(member)
+          else
+            emit(member)
+          end
+          emit(', ') if index < max
+        end
+      end
+
+      def emit_defaults
+        return unless defaults?
+        emit(', ') if required?
+        visit(defaults)
+      end
+
+      def emit_splat
+        return unless splat?
+
+        emit(', ') if required? or defaults?
+        emit('*')
+        value = splat
+        unless value == :@unnamed_splat
+          emit(value)
+        end
+      end
+
+      def emit_block_arg
+        return unless block_arg?
+        emit(', ') if required? or defaults? or splat?
+        visit(block_arg)
+      end
+
+      def arguments
+        node.arguments
+      end
+
+      def dispatch
+        return unless any?
+
+        util = self.class
+
+        emit(util::OPEN)
+
+        emit_required
+        emit_defaults
+        emit_splat
+        emit_block_arg
+
+        emit(util::CLOSE)
+      end
+
+      class Block < self
+        OPEN = ' |'.freeze
+        CLOSE = '|'.freeze
+      end
+
+      class Method < self
+        OPEN = '('.freeze
+        CLOSE = ')'.freeze
+
+        class Generic < self
+          handle(Rubinius::AST::FormalArguments19)
+
+          def arguments
+            node
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/if.rb

@@ -0,0 +1,51 @@
+module ToSource
+  class Emitter
+    class If < self
+
+      handle(Rubinius::AST::If)
+
+    private
+
+      def if_branch?
+        !node.body.kind_of?(Rubinius::AST::NilLiteral)
+      end
+
+      def else_branch?
+        !node.else.kind_of?(Rubinius::AST::NilLiteral)
+      end
+
+      def dispatch
+        if else_branch? and !if_branch?
+          run(Unless, node)
+          return
+        end
+
+        normal_dispatch
+      end
+
+      def normal_dispatch
+        emit('if ')
+        visit(node.condition)
+        emit_if_branch
+        emit_else_branch
+        emit('end')
+      end
+
+      def emit_if_branch
+        indent
+        visit(node.body)
+        unindent
+      end
+
+      def emit_else_branch
+        body = node.else
+        return unless else_branch?
+        emit('else')
+        indent
+        visit(body)
+        unindent
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/iter.rb

@@ -0,0 +1,20 @@
+module ToSource
+  class Emitter
+    class Iter < self
+
+      handle(Rubinius::AST::Iter19)
+
+    private
+
+      def dispatch
+        emit(' do')
+        run(FormalArguments::Block)
+        indent
+        visit(node.body)
+        unindent
+        emit_end
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/keyword_value.rb

@@ -0,0 +1,43 @@
+module ToSource
+  class Emitter
+
+    class KeywordValue < self
+
+    private
+
+      def dispatch
+        emit(self.class::SYMBOL)
+        if value?
+          emit('(')
+          visit(node.value)
+          emit(')')
+        end
+      end
+
+      class Return < self
+        SYMBOL = :return
+        handle(Rubinius::AST::Return)
+
+      private
+
+        def value?
+          !!node.value
+        end
+      end
+
+      class Break < self
+
+        handle(Rubinius::AST::Break)
+
+        SYMBOL = :break
+
+        def value?
+          !node.value.kind_of?(Rubinius::AST::NilLiteral)
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/to_source/emitter/literal.rb

@@ -0,0 +1,239 @@
+module ToSource
+  class Emitter
+    class Literal < self
+
+      class EmptyArray < self
+
+        handle(Rubinius::AST::EmptyArray)
+
+        def dispatch
+          emit('[]')
+        end
+      end
+
+      class Array < self
+
+        handle(Rubinius::AST::ArrayLiteral)
+
+      private
+
+        def dispatch
+          emit('[')
+          run(Util::DelimitedBody, node.body)
+          emit(']')
+        end
+      end
+
+      class Range < self
+
+      private
+
+        def dispatch
+          visit(node.start)
+          emit(token)
+          visit(node.finish)
+        end
+
+        def token
+          self.class::TOKEN
+        end
+
+        class Inclusive < self
+          handle(Rubinius::AST::Range)
+          TOKEN = '..'
+        end
+
+        class Exclude < self
+          handle(Rubinius::AST::RangeExclude)
+          TOKEN = '...'
+        end
+
+      end
+
+      class Hash < self
+
+        handle(Rubinius::AST::HashLiteral)
+
+        def dispatch
+          body = node.array.each_slice(2).to_a
+
+          max = body.length - 1
+
+          emit '{'
+
+          body.each_with_index do |slice, index|
+            key, value = slice
+
+            visit(key)
+            emit ' => '
+            visit(value)
+
+            if index < max 
+              emit ', ' 
+            end
+          end
+
+          emit '}'
+        end
+
+      end
+
+      class Inspect < self
+
+        handle(Rubinius::AST::SymbolLiteral)
+
+        def dispatch
+          emit(value.inspect)
+        end
+
+        def value
+          node.value
+        end
+
+        class Static < self
+          def value
+            self.class::VALUE
+          end
+
+          class True < self
+            handle(Rubinius::AST::TrueLiteral)
+            VALUE = true
+          end
+
+          class False < self
+            handle(Rubinius::AST::FalseLiteral)
+            VALUE = false
+          end
+
+          class Nil < self
+            handle(Rubinius::AST::NilLiteral)
+            VALUE = nil
+          end
+        end
+
+        class Regexp < self
+
+          handle(Rubinius::AST::RegexLiteral)
+
+          def value
+            ::Regexp.new(node.source)
+          end
+        end
+
+        class String < self
+
+          handle(Rubinius::AST::StringLiteral)
+
+          def value
+            node.string
+          end
+        end
+      end
+
+      class Dynamic < self
+
+        def dispatch
+          emit(node.string.inspect[0..-2])
+          array.each_with_index do |member, index|
+            emit_member(member, index)
+          end
+        end
+
+        def array
+          node.array
+        end
+
+        def max
+          array.length - 1
+        end
+        memoize :max
+
+        def emit_primitive_member(member, index)
+          last = index < max ? -2 : -1
+          range = 1..last
+          emit(member.string.inspect[range])
+        end
+
+        def emit_member(member, index)
+          case member
+          when Rubinius::AST::StringLiteral
+            emit_primitive_member(member, index)
+          else
+            visit(member)
+          end
+        end
+
+        class Symbol < self
+
+          handle(Rubinius::AST::DynamicSymbol)
+
+          def dispatch
+            emit(':')
+            super
+          end
+
+        end
+
+        class String < self
+
+          handle(Rubinius::AST::DynamicString)
+
+        end
+
+        class Execute < self
+
+          handle(Rubinius::AST::DynamicExecuteString)
+
+          def dispatch
+            emit('`')
+            emit(node.string.inspect[1..-2])
+            array.each_with_index do |member, index|
+              emit_member(member, index)
+            end
+            emit('`')
+          end
+
+          def emit_primitive_member(member, index)
+            last = index < max ? -3 : -2
+            range = 1..last
+            emit(member.string.inspect[range])
+          end
+
+        end
+
+        class Regex < self
+
+          handle(Rubinius::AST::DynamicRegex)
+
+          def dispatch
+            emit('/')
+            emit(Regexp.new(node.string).inspect[1..-2])
+            array.each_with_index do |member, index|
+              emit_member(member, index)
+            end
+            emit('/')
+          end
+
+          def emit_primitive_member(member, index)
+            last = index < max ? -3 : -2
+            range = 1..last
+            emit(Regexp.new(member.string).inspect[range])
+          end
+
+        end
+      end
+
+
+      class PassThrough < self
+
+        handle(Rubinius::AST::FixnumLiteral)
+        handle(Rubinius::AST::FloatLiteral)
+
+        def dispatch
+          emit(node.value)
+        end
+
+      end
+    end
+  end
+end