unparser 0.4.8 → 0.5.3

data/lib/unparser/emitter/simple.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for simple nodes that generate a single token
+    class Simple < self
+      MAP = IceNine.deep_freeze(
+        __ENCODING__:      '__ENCODING__',
+        __FILE__:          '__FILE__',
+        __LINE__:          '__LINE__',
+        false:             'false',
+        forward_arg:       '...',
+        forwarded_args:    '...',
+        kwnilarg:          '**nil',
+        match_nil_pattern: '**nil',
+        nil:               'nil',
+        redo:              'redo',
+        retry:             'retry',
+        self:              'self',
+        true:              'true',
+        zsuper:            'super'
+      )
+
+      handle(*MAP.keys)
+
+    private
+
+      def dispatch
+        write(MAP.fetch(node_type))
+      end
+    end # Simple
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/splat.rb

@@ -4,44 +4,28 @@ module Unparser
   class Emitter
     # Emitter for splats
     class KwSplat < self
-      include Terminated
-
       handle :kwsplat
 
       children :subject
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(T_SPLAT, T_SPLAT)
+        write('**')
         visit(subject)
       end
     end
 
     # Emitter for splats
     class Splat < self
-      include Terminated
-
       handle :splat
 
       children :subject
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(T_SPLAT)
+        write('*')
         visit(subject) if subject
       end
     end

data/lib/unparser/emitter/super.rb

@@ -3,42 +3,14 @@
 module Unparser
   class Emitter
 
-    # Emitter for zsuper nodes
-    class ZSuper < self
-      include Terminated
-
-      handle :zsuper
-
-    private
-
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def dispatch
-        write(K_SUPER)
-      end
-
-    end # ZSuper
-
     # Emitter for super nodes
     class Super < self
-      include Terminated
-
       handle :super
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_SUPER)
+        write('super')
         parentheses do
           delimited(children)
         end

data/lib/unparser/emitter/undef.rb

@@ -4,20 +4,12 @@ module Unparser
   class Emitter
     # Emitter for undef nodes
     class Undef < self
-      include Unterminated
-
       handle :undef
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_UNDEF, WS)
+        write('undef ')
         delimited(children)
       end
 

data/lib/unparser/emitter/variable.rb

@@ -5,20 +5,12 @@ module Unparser
 
     # Emitter for various variable accesses
     class Variable < self
-      include Terminated
-
       handle :ivar, :lvar, :cvar, :gvar, :back_ref
 
       children :name
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         write(name.to_s)
       end
@@ -27,43 +19,27 @@ module Unparser
 
     # Emitter for constant access
     class Const < self
-      include Terminated
-
       handle :const
 
       children :scope, :name
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         emit_scope
         write(name.to_s)
       end
 
-      # Emit parent
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_scope
         return unless scope
 
         visit(scope)
-        write(T_DCL) unless scope.type.equal?(:cbase)
+        write('::') unless n_cbase?(scope)
       end
     end
 
     # Emitter for nth_ref nodes (regexp captures)
     class NthRef < self
-      include Terminated
-
       PREFIX = '$'.freeze
       handle :nth_ref
 
@@ -71,12 +47,6 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         write(PREFIX)
         write(name.to_s)

data/lib/unparser/emitter/xstr.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Dynamic execute string literal emitter
+    class XStr < self
+
+      handle :xstr
+
+    private
+
+      def dispatch
+        if heredoc?
+          emit_heredoc
+        else
+          emit_xstr
+        end
+      end
+
+      def heredoc?
+        children.any? { |node| node.eql?(s(:str, '')) }
+      end
+
+      def emit_heredoc
+        write(%(<<~`HEREDOC`))
+        buffer.indent
+        nl
+        children.each do |child|
+          if n_str?(child)
+            write(child.children.first)
+          else
+            emit_begin(child)
+          end
+        end
+        buffer.unindent
+        write("HEREDOC\n")
+      end
+
+      def emit_xstr
+        write('`')
+        children.each do |child|
+          if n_begin?(child)
+            emit_begin(child)
+          else
+            emit_string(child)
+          end
+        end
+        write('`')
+      end
+
+      def emit_string(value)
+        write(escape_xstr(value.children.first))
+      end
+
+      def escape_xstr(input)
+        input.chars.map do |char|
+          if char.eql?('`')
+            '\\`'
+          else
+            char
+          end
+        end.join
+      end
+
+      def emit_begin(component)
+        write('#{')
+        visit(unwrap_single_begin(component))
+        write('}')
+      end
+    end # XStr
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/yield.rb

@@ -5,20 +5,12 @@ module Unparser
 
     # Emitter for yield node
     class Yield < self
-      include Terminated
-
       handle :yield
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_YIELD)
+        write('yield')
         return if children.empty?
 
         parentheses do

data/lib/unparser/generation.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Unparser
+  # rubocop:disable Metrics/ModuleLength
+  module Generation
+    EXTRA_NL = %i[kwbegin def defs module class sclass].freeze
+
+    private_constant(*constants(false))
+
+    def emit_heredoc_reminders; end
+
+    def symbol_name; end
+
+    def write_to_buffer
+      with_comments { dispatch }
+      self
+    end
+
+  private
+
+    def delimited(nodes, delimiter = ', ', &block)
+      return if nodes.empty?
+
+      emit_join(nodes, block || method(:visit), -> { write(delimiter) })
+    end
+
+    def emit_join(nodes, emit_node, emit_delimiter)
+      return if nodes.empty?
+
+      head, *tail = nodes
+      emit_node.call(head)
+
+      tail.each do |node|
+        emit_delimiter.call
+        emit_node.call(node)
+      end
+    end
+
+    def nl
+      emit_eol_comments
+      buffer.nl
+    end
+
+    def with_comments
+      emit_comments_before if buffer.fresh_line?
+      yield
+      comments.consume(node)
+    end
+
+    def ws
+      write(' ')
+    end
+
+    def emit_eol_comments
+      comments.take_eol_comments.each do |comment|
+        write(' ', comment.text)
+      end
+    end
+
+    def emit_eof_comments
+      emit_eol_comments
+      comments_left = comments.take_all
+      return if comments_left.empty?
+
+      buffer.nl
+      emit_comments(comments_left)
+    end
+
+    def emit_comments_before(source_part = :expression)
+      comments_before = comments.take_before(node, source_part)
+      return if comments_before.empty?
+
+      emit_comments(comments_before)
+      buffer.nl
+    end
+
+    def emit_comments(comments)
+      max = comments.size - 1
+      comments.each_with_index do |comment, index|
+        if comment.type.equal?(:document)
+          buffer.append_without_prefix(comment.text.chomp)
+        else
+          write(comment.text)
+        end
+        buffer.nl if index < max
+      end
+    end
+
+    def write(*strings)
+      strings.each(&buffer.method(:append))
+    end
+
+    def k_end
+      buffer.indent
+      emit_comments_before(:end)
+      buffer.unindent
+      write('end')
+    end
+
+    def parentheses(open = '(', close = ')')
+      write(open)
+      yield
+      write(close)
+    end
+
+    def indented
+      buffer = buffer()
+      buffer.indent
+      nl
+      yield
+      nl
+      buffer.unindent
+    end
+
+    def emit_optional_body(node, indent: true)
+      if node
+        emit_body(node, indent: indent)
+      else
+        nl
+      end
+    end
+
+    def emit_body(node, indent: true)
+      if indent
+        buffer.indent
+        nl
+      end
+
+      if n_begin?(node)
+        if node.children.one?
+          visit_deep(node)
+        else
+          emit_body_inner(node)
+        end
+      else
+        visit_deep(node)
+      end
+
+      if indent
+        buffer.unindent
+        nl
+      end
+    end
+
+    def emit_body_inner(node)
+      head, *tail = node.children
+      emit_body_member(head)
+
+      tail.each do |child|
+        nl
+
+        nl if EXTRA_NL.include?(child.type)
+
+        emit_body_member(child)
+      end
+    end
+
+    def emit_body_member(node)
+      if n_rescue?(node)
+        emit_rescue_postcontrol(node)
+      else
+        visit_deep(node)
+      end
+    end
+
+    def emit_ensure(node)
+      body, ensure_body = node.children
+
+      if body
+        emit_body_rescue(body)
+      else
+        nl
+      end
+
+      write('ensure')
+
+      emit_optional_body(ensure_body)
+    end
+
+    def emit_body_rescue(node)
+      if n_rescue?(node)
+        emit_rescue_regular(node)
+      else
+        emit_body(node)
+      end
+    end
+
+    def emit_optional_body_ensure_rescue(node)
+      if node
+        emit_body_ensure_rescue(node)
+      else
+        nl
+      end
+    end
+
+    def emit_body_ensure_rescue(node)
+      if n_ensure?(node)
+        emit_ensure(node)
+      elsif n_rescue?(node)
+        emit_rescue_regular(node)
+      else
+        emit_body(node)
+      end
+    end
+
+    def emit_rescue_postcontrol(node)
+      writer_with(Writer::Rescue, node).emit_postcontrol
+    end
+
+    def emit_rescue_regular(node)
+      writer_with(Writer::Rescue, node).emit_regular
+    end
+
+    def writer_with(klass, node)
+      klass.new(to_h.merge(node: node))
+    end
+
+    def emitter(node)
+      Emitter.emitter(**to_h.merge(node: node))
+    end
+
+    def visit(node)
+      emitter(node).write_to_buffer
+    end
+
+    def visit_deep(node)
+      emitter(node).tap do |emitter|
+        emitter.write_to_buffer
+        emitter.emit_heredoc_reminders
+      end
+    end
+
+    def first_child
+      children.first
+    end
+
+    def conditional_parentheses(flag, &block)
+      if flag
+        parentheses(&block)
+      else
+        block.call
+      end
+    end
+
+    def children
+      node.children
+    end
+  end # Generation
+  # rubocop:enable Metrics/ModuleLength
+end # Unparser