unparser 0.4.9 → 0.5.0

data/lib/unparser/emitter/kwbegin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for explicit begins
+    class KWBegin < self
+      handle :kwbegin
+
+    private
+
+      def dispatch
+        write('begin')
+
+        if children.one?
+          emit_body_ensure_rescue(children.first)
+        else
+          indented do
+            emit_multiple_body
+          end
+        end
+
+        k_end
+      end
+
+      def emit_multiple_body
+        emit_join(children, method(:emit_body_member), method(:nl))
+      end
+
+    end # KWBegin
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/lambda.rb

@@ -4,18 +4,10 @@ module Unparser
   class Emitter
     # Emitter for lambda nodes
     class Lambda < self
-      include Terminated
-
       handle :lambda
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         write('->')
       end

data/lib/unparser/emitter/masgn.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for multiple assignment nodes
+    class MASGN < self
+      handle :masgn
+
+      children :target, :source
+
+    private
+
+      def dispatch
+        visit(target)
+        write(' = ')
+        visit(source)
+      end
+    end # MLHS
+  end # Emitter
+end # Unaprser

data/lib/unparser/emitter/match.rb

@@ -5,10 +5,6 @@ module Unparser
 
     # Base class for special match node emitters
     class Match < self
-      include Unterminated
-
-      OPERATOR = '=~'.freeze
-
       # Emitter for match with local variable assignment
       class Lvasgn < self
         handle :match_with_lvasgn
@@ -17,15 +13,9 @@ module Unparser
 
       private
 
-        # Perform dispatch
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
         def dispatch
           visit(regexp)
-          write(WS, OPERATOR, WS)
+          write(' =~ ')
           visit(lvasgn)
         end
 
@@ -37,12 +27,8 @@ module Unparser
 
         children :regexp
 
-        # Perform dispatch
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
+      private
+
         def dispatch
           visit(regexp)
         end

data/lib/unparser/emitter/match_alt.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class MatchAlt < self
+
+      handle :match_alt
+
+      children :left, :right
+
+    private
+
+      def dispatch
+        visit(left)
+        ws
+        write('|')
+        ws
+        visit(right)
+      end
+    end # MatchAlt
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/match_as.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class MatchAs < self
+
+      handle :match_as
+
+      children :left, :right
+
+    private
+
+      def dispatch
+        visit(left)
+        write(' => ')
+        visit(right)
+      end
+    end # MatchAs
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/match_rest.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emiter for match rest nodes
+    class MatchRest < self
+      children :match_var
+
+      def emit_array_pattern
+        write('*')
+        emit_match_var
+      end
+
+      def emit_hash_pattern
+        write('**')
+        emit_match_var
+      end
+
+    private
+
+      def emit_match_var
+        visit(match_var) if match_var
+      end
+    end # MatchRest
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/match_var.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class MatchVar < self
+
+      handle :match_var
+
+      children :name
+
+    private
+
+      def dispatch
+        write(name.to_s)
+      end
+    end # MatchVar
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/mlhs.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for multiple assignment left hand side
+    class MLHS < self
+      handle :mlhs
+
+      NO_COMMA = %i[arg splat mlhs restarg].freeze
+
+      private_constant(*constants(false))
+
+    private
+
+      def dispatch
+        if children.one?
+          emit_one_child_mlhs
+        else
+          emit_many
+        end
+      end
+
+      def emit_one_child_mlhs
+        child = children.first
+        parentheses do
+          emitter(child).emit_mlhs
+          write(',') unless NO_COMMA.include?(child.type)
+        end
+      end
+
+      def emit_many
+        parentheses do
+          delimited(children) do |node|
+            emitter(node).emit_mlhs
+          end
+        end
+      end
+    end # MLHS
+  end # Emitter
+end # Unaprser

data/lib/unparser/emitter/module.rb

@@ -4,7 +4,7 @@ module Unparser
   class Emitter
     # Emitter for module nodes
     class Module < self
-      include LocalVariableRoot, Terminated
+      include LocalVariableRoot
 
       handle :module
 
@@ -12,16 +12,10 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_MODULE, WS)
+        write('module ')
         visit(name)
-        emit_body
+        emit_optional_body(body)
         k_end
       end
 

data/lib/unparser/emitter/op_assign.rb

@@ -5,8 +5,6 @@ module Unparser
 
     # Base class for and and or op-assign
     class BinaryAssign < self
-      include Unterminated
-
       children :target, :expression
 
       MAP = IceNine.deep_freeze(
@@ -16,17 +14,16 @@ module Unparser
 
       handle(*MAP.keys)
 
+      def emit_heredoc_reminders
+        emitter(target).emit_heredoc_reminders
+        emitter(expression).emit_heredoc_reminders
+      end
+
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        visit(target)
-        write(WS, MAP.fetch(node.type), WS)
+        emitter(target).emit_mlhs
+        write(' ', MAP.fetch(node.type), ' ')
         visit(expression)
       end
 
@@ -34,32 +31,20 @@ module Unparser
 
     # Emitter for op assign
     class OpAssign < self
-      include Unterminated
-
       handle :op_asgn
 
+      children :target, :operator, :value
+
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        visit(first_child)
+        emitter(first_child).emit_mlhs
         emit_operator
-        visit(children[2])
+        visit(value)
       end
 
-      # Emit operator
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_operator
-        write(WS, children[1].to_s, T_ASN, WS)
+        write(' ', operator.to_s, '= ')
       end
 
     end # OpAssign

data/lib/unparser/emitter/pin.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for pin nodes
+    class Pin < self
+      handle :pin
+
+      children :target
+
+    private
+
+      def dispatch
+        write('^')
+        visit(target)
+      end
+    end # Pin
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/primitive.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Base class for primitive emitters
+    class Primitive < self
+
+      children :value
+
+      # Emitter for primitives based on Object#inspect
+      class Inspect < self
+
+        handle :sym, :str
+
+      private
+
+        def dispatch
+          write(value.inspect)
+        end
+
+      end # Inspect
+
+      # Emitter for complex literals
+      class Complex < self
+
+        handle :complex
+
+        RATIONAL_FORMAT = 'i'.freeze
+
+        MAP =
+          IceNine.deep_freeze(
+            ::Float    => :float,
+            ::Rational => :rational,
+            ::Integer  => :int
+          )
+
+      private
+
+        def dispatch
+          emit_imaginary
+          write(RATIONAL_FORMAT)
+        end
+
+        def emit_imaginary
+          visit(imaginary_node)
+        end
+
+        def imaginary_node
+          imaginary = value.imaginary
+          s(MAP.fetch(imaginary.class), imaginary)
+        end
+
+      end # Rational
+
+      # Emitter for rational literals
+      class Rational < self
+
+        handle :rational
+
+        RATIONAL_FORMAT = 'r'.freeze
+
+      private
+
+        # rubocop:disable Lint/FloatComparison
+        def dispatch
+          integer = Integer(value)
+          float   = value.to_f
+
+          write_rational(integer.to_f.equal?(float) ? integer : float)
+        end
+        # rubocop:enable Lint/FloatComparison
+
+        def write_rational(value)
+          write(value.to_s, RATIONAL_FORMAT)
+        end
+
+      end # Rational
+
+      # Emiter for numeric literals
+      class Numeric < self
+
+        handle :int
+
+      private
+
+        def dispatch
+          write(value.inspect)
+        end
+
+      end # Numeric
+    end # Primitive
+  end # Emitter
+end # Unparser