unparser 0.4.7 → 0.6.7

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
+        emit_block_arguments unless n_lambda?(target)
+        target_writer.emit_heredoc_reminders if n_send?(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

data/lib/unparser/emitter/class.rb

@@ -4,7 +4,7 @@ module Unparser
   class Emitter
     # Emitter for class nodes
     class Class < self
-      include LocalVariableRoot, Terminated
+      include LocalVariableRoot
 
       handle :class
 
@@ -12,30 +12,18 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_CLASS, WS)
+        write('class ')
         visit(name)
         emit_superclass
-        emit_body
+        emit_optional_body(body)
         k_end
       end
 
-      # Emit superclass
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_superclass
         return unless superclass
 
-        write(WS, T_LT, WS)
+        write(' < ')
         visit(superclass)
       end
 
@@ -43,24 +31,16 @@ module Unparser
 
     # Emitter for sclass nodes
     class SClass < self
-      include Terminated
-
       handle :sclass
 
       children :object, :body
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_CLASS, WS, T_DLT, WS)
+        write('class << ')
         visit(object)
-        emit_body
+        emit_optional_body(body)
         k_end
       end
 

data/lib/unparser/emitter/const_pattern.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for const pattern node
+    class ConstPattern < self
+
+      handle :const_pattern
+
+      children :const, :pattern
+
+    private
+
+      def dispatch
+        visit(const)
+        if n_hash_pattern?(pattern)
+          emitter(pattern).emit_const_pattern
+        else
+          visit(pattern)
+        end
+      end
+    end # ConstPattern
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/def.rb

@@ -4,70 +4,40 @@ module Unparser
   class Emitter
     # Emitter for def node
     class Def < self
-      include LocalVariableRoot, Terminated
+      include LocalVariableRoot
 
     private
 
-      # Emit name
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       abstract_method :emit_name
       private :emit_name
 
-      # Return body node
-      #
-      # @return [Parser::AST::Node]
-      #
-      # @api private
-      #
       abstract_method :body
       private :body
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_DEF, WS)
+        write('def ')
         emit_name
-        comments.consume(node, :name)
         emit_arguments
-        emit_body
+        emit_optional_body_ensure_rescue(body)
         k_end
       end
 
-      # Emit arguments
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_arguments
         return if arguments.children.empty?
 
-        visit_parentheses(arguments)
+        parentheses do
+          writer_with(Args, arguments).emit_def_arguments
+        end
       end
 
       # Instance def emitter
       class Instance < self
-
         handle :def
 
         children :name, :arguments, :body
 
       private
 
-        # Emit name
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
         def emit_name
           write(name.to_s)
         end
@@ -83,25 +53,13 @@ module Unparser
 
       private
 
-        # Return mame
-        #
-        # @return [String]
-        #
-        # @api private
-        #
         def emit_name
           conditional_parentheses(!subject_without_parens?) do
             visit(subject)
           end
-          write(T_DOT, name.to_s)
+          write('.', name.to_s)
         end
 
-        # Test if subject needs parentheses
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        #
         def subject_without_parens?
           case subject.type
           when :self
@@ -111,8 +69,6 @@ module Unparser
           when :send
             receiver, _selector, *arguments = *subject
             !receiver && arguments.empty?
-          else
-            false
           end
         end
 

data/lib/unparser/emitter/defined.rb

@@ -4,25 +4,15 @@ module Unparser
   class Emitter
     # Emitter for defined? nodes
     class Defined < self
-      include Terminated
-
       handle :defined?
 
       children :subject
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_DEFINED)
-        parentheses do
-          visit(subject)
-        end
+        write('defined?')
+        parentheses { visit(subject) }
       end
 
     end # Defined

data/lib/unparser/emitter/dstr.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Dynamic string emitter
+    class DStr < self
+
+      handle :dstr
+
+      def emit_heredoc_reminders
+        writer_with(Writer::DynamicString, node).emit_heredoc_reminder
+      end
+
+    private
+
+      def dispatch
+        writer_with(Writer::DynamicString, node).dispatch
+      end
+
+    end # DStr
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/dsym.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Dynamic symbol literal emitter
+    class DSym < self
+      handle :dsym
+
+    private
+
+      def dispatch
+        write(':"')
+        children.each do |child|
+          case child.type
+          when :str
+            emit_str_child(child)
+          when :begin
+            emit_begin_child(child)
+          end
+        end
+        write('"')
+      end
+
+      def emit_str_child(value)
+        string = value.children.first
+        if string.end_with?("\n")
+          write(string.inspect[1..-4])
+          nl
+        else
+          write(string.inspect[1..-2])
+        end
+      end
+
+      def emit_begin_child(component)
+        write('#{')
+        visit(unwrap_single_begin(component))
+        write('}')
+      end
+    end # DSym
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/find_pattern.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class FindPattern < self
+      handle :find_pattern
+
+    private
+
+      def dispatch
+        write('[')
+        delimited(children)
+        write(']')
+      end
+    end # FindPattern
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/flipflop.rb

@@ -4,12 +4,19 @@ module Unparser
   class Emitter
     # Emitter for flip flops
     class FlipFlop < self
-      include Unterminated
-
-      MAP = IceNine.deep_freeze(
+      MAP = {
         iflipflop: '..',
         eflipflop: '...'
-      ).freeze
+      }.freeze
+
+      SYMBOLS = {
+        eflipflop: :tDOT3,
+        iflipflop: :tDOT2
+      }.freeze
+
+      def symbol_name
+        true
+      end
 
       handle(*MAP.keys)
 
@@ -17,12 +24,6 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         visit(left)
         write(MAP.fetch(node.type))

data/lib/unparser/emitter/float.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emiter for float literals
+    class Float < self
+      handle :float
+
+      children :value
+
+      INFINITY     = ::Float::INFINITY
+      NEG_INFINITY = -::Float::INFINITY
+
+    private
+
+      def dispatch
+        case value
+        when INFINITY
+          write('10e1000000000000000000')
+        when NEG_INFINITY
+          write('-10e1000000000000000000')
+        else
+          write(value.inspect)
+        end
+      end
+
+    end # Float
+  end # Emitter
+end # Unparser