to_source 0.2.16 → 0.2.17

data/lib/to_source/emitter/literal.rb

@@ -171,24 +171,6 @@ module ToSource
           end
         end
 
-        # Emitter for regexp literal nodes
-        class Regexp < self
-
-          handle(Rubinius::AST::RegexLiteral)
-
-        private
-
-          # Return value to inspect
-          #
-          # @return [Regexp]
-          #
-          # @api private
-          #
-          def value
-            ::Regexp.new(node.source)
-          end
-        end
-
         # Emitter for string litera nodes
         class String < self
 
@@ -212,6 +194,7 @@ module ToSource
       class PassThrough < self
 
         handle(Rubinius::AST::FixnumLiteral)
+        handle(Rubinius::AST::NumberLiteral)
         handle(Rubinius::AST::FloatLiteral)
 
       private

data/lib/to_source/emitter/literal/dynamic.rb

@@ -149,29 +149,6 @@ module ToSource
           OPEN = CLOSE = '`'.freeze
 
         end
-
-        # Emitter for dynamic regexp literals
-        class Regex < self
-
-          handle(Rubinius::AST::DynamicRegex)
-          OPEN = CLOSE = '/'.freeze
-
-        private
-
-          # Emit literal
-          #
-          # @param [String] literal
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def emit_literal(literal)
-            emit(literal)
-          end
-
-        end
-
       end
     end
   end

data/lib/to_source/emitter/literal/dynamic/regexp.rb

@@ -0,0 +1,69 @@
+module ToSource
+  class Emitter
+    class Literal
+      class Dynamic
+
+        # Emitter for dynamic regexp literals
+        class Regex < self
+
+          handle(Rubinius::AST::DynamicRegex)
+          OPEN = CLOSE = '/'.freeze
+
+        private
+
+          # Perform dispatch
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            super
+            emit_flags
+          end
+
+          # Emit flags
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_flags
+            run(Literal::Regexp::Options, node.options)
+          end
+
+          # Emit literal
+          #
+          # @param [String] literal
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_literal(literal)
+            emit(literal)
+          end
+
+          class Once < self
+
+            handle(Rubinius::AST::DynamicOnceRegex)
+
+          private
+
+            # Emit flags
+            #
+            # @return [undefined]
+            #
+            # @api private
+            #
+            def emit_flags
+              emit('o')
+              super
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/to_source/emitter/literal/regexp.rb

@@ -0,0 +1,27 @@
+module ToSource
+  class Emitter
+    class Literal
+      # Emitter for regexp literal nodes
+      class Regexp < self
+
+        handle(Rubinius::AST::RegexLiteral)
+
+      private
+
+        delegate(:options)
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit("/#{node.source}/")
+          run(Options, options)
+        end
+
+      end
+    end
+  end
+end

data/lib/to_source/emitter/literal/regexp/options.rb

@@ -0,0 +1,71 @@
+module ToSource
+  class Emitter
+    class Literal
+      class Regexp
+        class Options < Emitter
+
+          # No constants for this under ::Regexp in MRI
+          # So stole this from nice player rubinius kernel/common/regexp.rb
+          KCODE_NONE = (1 << 9)
+          KCODE_EUC  = (2 << 9)
+          KCODE_SJIS = (3 << 9)
+          KCODE_UTF8 = (4 << 9)
+          KCODE_MASK = KCODE_NONE | KCODE_EUC | KCODE_SJIS | KCODE_UTF8
+
+          GENERIC = IceNine.deep_freeze(
+            ::Regexp::EXTENDED      => 'x',
+            # FIXME: Documented but no option flag?
+            #::Regexp::FIXEDENCODING => '',
+            ::Regexp::IGNORECASE    => 'i',
+            ::Regexp::MULTILINE     => 'm'
+          )
+
+          KCODES = IceNine.deep_freeze(
+            KCODE_NONE  => 'n',
+            KCODE_EUC   => 'e',
+            KCODE_SJIS  => 's',
+            KCODE_UTF8  => 'u'
+          )
+
+        private
+
+          # Perform dispatch
+          #
+          # @return [self]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_generic_flags
+            emit_kcode_flag
+          end
+
+          # Emit kcode flag
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_kcode_flag
+            emit(KCODES.fetch(node & KCODE_MASK, ''))
+          end
+
+          # Emit generic flags
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_generic_flags
+            GENERIC.each do |option, flag|
+              unless (node & option).zero?
+                emit(flag)
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/to_source/emitter/match.rb

@@ -0,0 +1,21 @@
+module ToSource
+  class Emitter
+    class Match < self
+
+      handle(Rubinius::AST::Match)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(node.pattern)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/match2.rb

@@ -0,0 +1,25 @@
+module ToSource
+  class Emitter
+    # Emitter for match operator
+    class Match2 < self
+
+      handle(Rubinius::AST::Match2)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        util = node
+        visit(util.pattern)
+        emit(' =~ ')
+        visit(util.value)
+      end
+
+    end
+  end
+end

data/lib/to_source/emitter/multiple_assignment.rb

@@ -1,5 +1,25 @@
 module ToSource
   class Emitter
+
+    class Splat < self
+      handle(Rubinius::AST::SplatArray)
+      handle(Rubinius::AST::SplatAssignment)
+      handle(Rubinius::AST::SplatWrapped)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit('*')
+        visit(node.value)
+      end
+    end
+
     # Emitter for multiple assignment nodes
     class MultipleAssignment < self
 
@@ -7,6 +27,9 @@ module ToSource
 
     private
 
+      delegate(:right, :splat, :left)
+      predicate(:right, :splat, :left)
+
       # Perform dispatch
       #
       # @return [undefined]
@@ -15,8 +38,11 @@ module ToSource
       #
       def dispatch
         emit_left
-        emit(' = ')
-        emit_right
+        emit_splat
+        if right?
+          emit(' = ')
+          emit_right 
+        end
       end
 
       # Emit left
@@ -26,10 +52,23 @@ module ToSource
       # @api private
       #
       def emit_left
-        run(Util::DelimitedBody, node.left.body)
+        return unless left?
+        run(Util::DelimitedBody, left.body)
       end
 
-      # Emit left
+      # Emit splat
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_splat
+        return unless splat?
+        emit(', ') if left?
+        visit(splat)
+      end
+
+      # Emit right
       #
       # @return [undefined]
       #

data/lib/to_source/emitter/op_assign1.rb

@@ -7,6 +7,8 @@ module ToSource
 
     private
 
+      delegate(:receiver, :value)
+
       # Perform dispatch
       #
       # @return [undefined]
@@ -14,12 +16,42 @@ module ToSource
       # @api private
       #
       def dispatch
-        util = node
-        visit(util.receiver)
+        visit(receiver)
         emit('[')
-        visit(util.arguments.array.first)
-        emit('] ||= ')
-        visit(util.value)
+        emit_index
+        emit("] #{operator} ")
+        visit(value)
+      end
+
+      # Emit index
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_index
+        arguments = node.arguments
+        array = arguments.array
+        if array.any?
+          visit(array.first)
+          return
+        end
+      end
+
+      MAPPING = {
+        :or =>  :'||',
+        :and => :'&&'
+      }.freeze
+
+      # Return operator
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def operator
+        op = node.op
+        "#{MAPPING.fetch(op, op)}="
       end
 
     end

data/lib/to_source/emitter/push_args.rb

@@ -0,0 +1,42 @@
+module ToSource
+  class Emitter
+
+    class PushArgs < self
+
+    private
+
+      delegate(:arguments, :value)
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        visit(arguments)
+        emit(', ')
+        visit(value)
+      end
+
+      class Array < self
+
+        handle(Rubinius::AST::PushArgs)
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit('[')
+          super
+          emit(']')
+        end
+      end
+    end
+  end
+end