unparser 0.4.5 → 0.5.0

data/lib/unparser/emitter/begin.rb

@@ -5,97 +5,22 @@ module Unparser
 
     # Emitter for begin nodes
     class Begin < self
-
+      handle :begin
       children :body
 
-    private
-
-      # Emit inner nodes
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def emit_inner
-        children.each_with_index do |child, index|
-          visit_plain(child)
-          write(NL) if index < children.length - 1
+      def emit_heredoc_reminders
+        children.each do |child|
+          emitter(child).emit_heredoc_reminders
         end
       end
 
-      # Emitter for implicit begins
-      class Implicit < self
-
-        handle :begin
-
-        # Test if begin is terminated
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        #
-        def terminated?
-          children.empty?
-        end
-
-        TERMINATING_PARENT = %i[root interpolated dyn_str_body].to_set.freeze
-
-      private
-
-        # Perform dispatch
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
-        def dispatch
-          if terminated? && !TERMINATING_PARENT.include?(parent_type)
-            write('()')
-          else
-            emit_inner
-          end
-        end
-
-      end # Implicit
-
-      # Emitter for explicit begins
-      class Explicit < self
-        include Terminated
-
-        handle :kwbegin
-
-      private
-
-        # Perform dispatch
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
-        def dispatch
-          write(K_BEGIN)
-          emit_body
-          k_end
-        end
+    private
 
-        # Emit body
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
-        def emit_body
-          if body.nil?
-            nl
-          elsif NOINDENT.include?(body.type)
-            emit_inner
-          else
-            indented { emit_inner }
-          end
+      def dispatch
+        parentheses do
+          delimited(children, '; ')
         end
-
-      end # Explicit
-
+      end
     end # Begin
   end # Emitter
 end # Unparser

data/lib/unparser/emitter/binary.rb

@@ -2,33 +2,20 @@
 
 module Unparser
   class Emitter
-    # Base class for binary emitters
+    # Non send binary operator / keyword emitter
     class Binary < self
-      include Unterminated
-
-      children :left, :right
-
-      MAP = {
-        or:  T_OR,
-        and: T_AND
-      }.freeze
-
-      handle(*MAP.keys)
+      handle :and, :or
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        visit(left)
-        write(WS, MAP.fetch(node.type), WS)
-        visit(right)
+        writer.dispatch
       end
 
+      def writer
+        writer_with(Writer::Binary, node)
+      end
+      memoize :writer
     end # Binary
   end # Emitter
 end # Unparser

data/lib/unparser/emitter/block.rb

@@ -4,66 +4,82 @@ module Unparser
   class Emitter
 
     # Block emitter
-    #
-    # ignore :reek:RepeatedConditional
     class Block < self
-      include Terminated
-
-      handle :block
+      handle :block, :numblock
 
       children :target, :arguments, :body
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         emit_target
-        write(WS, K_DO)
-        emit_block_arguments unless stabby_lambda?
-        emit_body
-        k_end
+        ws
+        write_open
+        target_writer.emit_heredoc_reminders if n_send?(target)
+        emit_block_arguments unless n_lambda?(target)
+        emit_optional_body_ensure_rescue(body)
+        write_close
       end
 
-      # Emit target
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def emit_target
-        visit(target)
+      def need_do?
+        body && (n_rescue?(body) || n_ensure?(body))
+      end
+
+      def write_open
+        if need_do?
+          write('do')
+        else
+          write('{')
+        end
+      end
 
-        if stabby_lambda?
-          parentheses { visit(arguments) }
+      def write_close
+        if need_do?
+          k_end
+        else
+          write('}')
         end
       end
 
-      # Test if we are emitting a stabby lambda
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def stabby_lambda?
-        target.type.equal?(:lambda)
+      def target_writer
+        writer_with(Writer::Send::Regular, target)
+      end
+      memoize :target_writer
+
+      def emit_target
+        case target.type
+        when :send
+          emit_send_target
+        when :lambda
+          visit(target)
+          emit_lambda_arguments unless node.type.equal?(:numblock)
+        else
+          visit(target)
+        end
+      end
+
+      def emit_send_target
+        target_writer.emit_receiver
+        target_writer.emit_selector
+        target_writer.emit_arguments_without_heredoc_body
+      end
+
+      def emit_lambda_arguments
+        parentheses { writer_with(Args, arguments).emit_lambda_arguments }
+      end
+
+      def numblock?
+        node.type.equal?(:numblock)
       end
 
-      # Emit arguments
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_block_arguments
-        return if arguments.children.empty?
+        return if numblock? || arguments.children.empty?
 
         ws
-        visit_parentheses(arguments, T_PIPE, T_PIPE)
+
+        parentheses('|', '|') do
+          writer_with(Args, arguments).emit_block_arguments
+        end
       end
 
     end # Block

data/lib/unparser/emitter/case.rb

@@ -4,8 +4,6 @@ module Unparser
   class Emitter
     # Emitter for case nodes
     class Case < self
-      include Terminated
-
       handle :case
 
       children :condition
@@ -13,89 +11,49 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_CASE)
+        write('case')
         emit_condition
         emit_whens
         emit_else
         k_end
       end
 
-      # Emit else
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_else
         else_branch = children.last
         return unless else_branch
 
-        write(K_ELSE)
-        visit_indented(else_branch)
+        write('else')
+        emit_body(else_branch)
       end
 
-      # Emit whens
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_whens
         nl
         whens.each(&method(:visit))
       end
 
-      # Emit condition
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_condition
         return unless condition
 
-        write(WS)
+        ws
         visit(condition)
       end
-
     end # Case
 
     # Emitter for when nodes
     class When < self
-      include Terminated
-
       handle :when
 
       define_group :captures, 0..-2
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_WHEN, WS)
+        write('when ')
         emit_captures
-        body = children.last
-        emit_body(body)
+        emit_optional_body(children.last)
       end
 
-      # Emit captures
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_captures
         delimited(captures)
       end

data/lib/unparser/emitter/case_guard.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for case guards
+    class CaseGuard < self
+
+      handle :if_guard, :unless_guard
+
+      MAP = {
+        if_guard:     'if',
+        unless_guard: 'unless'
+      }.freeze
+
+      children :condition
+
+    private
+
+      def dispatch
+        write(MAP.fetch(node_type))
+        ws
+        visit(condition)
+      end
+
+    end # UnlessGuard
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/case_match.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for case matches
+    class CaseMatch < self
+
+      handle :case_match
+
+      children :target
+
+      define_group :patterns, 1..-2
+
+    private
+
+      def else_branch
+        children.last
+      end
+
+      def dispatch
+        write('case ')
+        visit(target)
+        nl
+        patterns.each(&method(:visit))
+        nl unless buffer.fresh_line?
+        emit_else_branch
+        k_end
+      end
+
+      def emit_else_branch
+        if else_branch
+          write('else')
+          emit_body(else_branch) unless n_empty_else?(else_branch)
+          nl unless buffer.fresh_line?
+        end
+      end
+
+    end # CaseMatch
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/cbase.rb

@@ -4,8 +4,6 @@ module Unparser
   class Emitter
     # Emitter for toplevel constant reference nodes
     class CBase < self
-      include Terminated
-
       handle :cbase
 
     private
@@ -17,7 +15,7 @@ module Unparser
       # @api private
       #
       def dispatch
-        write(T_DCL)
+        write('::')
       end
 
     end # CBase