unparser 0.4.7 → 0.6.7

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_pattern.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class MatchPattern < self
+
+      handle :match_pattern
+
+      children :target, :pattern
+
+      # Modern ast format emits `match_pattern`
+      # node on single line pre 3.0, but 3.0+ uses `match_pattern_p`
+      SYMBOL =
+        if RUBY_VERSION < '3.0'
+          ' in '
+        else
+          ' => '
+        end
+
+    private
+
+      def dispatch
+        visit(target)
+        write(SYMBOL)
+        visit(pattern)
+      end
+    end # MatchPattern
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/match_pattern_p.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    class MatchPatternP < self
+
+      handle :match_pattern_p
+
+      children :target, :pattern
+
+    private
+
+      def dispatch
+        visit(target)
+        write(' in ')
+        visit(pattern)
+      end
+    end # MatchPatternP
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/match_rest.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emiter for match rest nodes
+    class MatchRest < self
+      handle :match_rest
+
+      children :match_var
+
+      def dispatch
+        write('*')
+        visit(match_var) if match_var
+      end
+
+      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,28 +5,25 @@ module Unparser
 
     # Base class for and and or op-assign
     class BinaryAssign < self
-      include Unterminated
-
       children :target, :expression
 
-      MAP = IceNine.deep_freeze(
+      MAP = {
         and_asgn: '&&=',
         or_asgn:  '||='
-      )
+      }.freeze
 
       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/pair.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for key value pairs in hash literals or kwargs
+    class Pair < self
+      BAREWORD = /\A[A-Za-z_][A-Za-z_0-9]*[?!]?\z/.freeze
+
+      private_constant(*constants(false))
+
+      handle :pair
+
+      children :key, :value
+
+    private
+
+      def dispatch
+        if colon?(key)
+          write(key.children.first.to_s, ': ')
+        else
+          visit(key)
+          write(' => ')
+        end
+
+        visit(value)
+      end
+
+      def colon?(key)
+        n_sym?(key) && BAREWORD.match?(key.children.first)
+      end
+    end
+  end
+end

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 =
+          {
+            ::Float    => :float,
+            ::Rational => :rational,
+            ::Integer  => :int
+          }.freeze
+
+      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

data/lib/unparser/emitter/range.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Range emitters
+    class Range < self
+      TOKENS = {
+        irange: '..',
+        erange: '...'
+      }.freeze
+
+      SYMBOLS = {
+        erange: :tDOT3,
+        irange: :tDOT2
+      }.freeze
+
+      def symbol_name
+        true
+      end
+
+      handle(*TOKENS.keys)
+
+      children :begin_node, :end_node
+
+    private
+
+      def dispatch
+        visit(begin_node) if begin_node
+        write(TOKENS.fetch(node.type))
+        visit(end_node) if end_node
+      end
+
+    end # Range
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/regexp.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for regexp literals
+    class Regexp < self
+      handle :regexp
+
+      define_group(:body, 0..-2)
+
+    private
+
+      def dispatch
+        parentheses('/', '/') do
+          body.each(&method(:emit_body))
+        end
+        emit_options
+      end
+
+      def emit_options
+        write(children.last.children.join)
+      end
+
+      def emit_body(node)
+        if n_begin?(node)
+          write('#{')
+          node.children.each(&method(:visit))
+          write('}')
+        else
+          buffer.append_without_prefix(node.children.first.gsub('/', '\/'))
+        end
+      end
+    end # Regexp
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/repetition.rb

@@ -5,39 +5,29 @@ module Unparser
 
     # Emitter for postconditions
     class Post < self
-      include Unterminated
-
-      handle :while_post, :until_post
-
       children :condition, :body
 
       MAP = {
-        while_post: K_WHILE,
-        until_post: K_UNTIL
+        while_post: 'while',
+        until_post: 'until'
       }.freeze
 
       handle(*MAP.keys)
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
+    private
+
       def dispatch
         visit(body)
-        write(WS, MAP.fetch(node.type), WS)
+        write(' ', MAP.fetch(node.type), ' ')
         visit(condition)
       end
     end
 
-    # Base class for while and until emitters
+    # Emitter for while and until nodes
     class Repetition < self
-      include Terminated
-
       MAP = {
-        while: K_WHILE,
-        until: K_UNTIL
+        while: 'while',
+        until: 'until'
       }.freeze
 
       handle(*MAP.keys)
@@ -46,12 +36,6 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         if postcontrol?
           emit_postcontrol
@@ -60,54 +44,30 @@ module Unparser
         end
       end
 
-      # Test if node must be emitted in postcontrol form
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
       def postcontrol?
-        return nil unless body # greez from falsyness
-
-        local_variable_scope.first_assignment_in_body_and_used_in_condition?(body, condition)
+        body && local_variable_scope.first_assignment_in?(body, condition)
       end
 
-      # Emit keyword
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_keyword
-        write(MAP.fetch(node.type), WS)
+        write(MAP.fetch(node.type), ' ')
       end
 
-      # Emit embedded
-      #
-      # @return [undefned]
-      #
-      # @api private
-      #
       def emit_normal
         emit_keyword
-        conditional_parentheses(condition.type.equal?(:block)) do
-          visit(condition)
+        visit(condition)
+        if body
+          emit_body(body)
+        else
+          nl
         end
-        emit_body
         k_end
       end
 
-      # Emit postcontrol
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_postcontrol
-        visit_plain(body)
+        visit(body)
         ws
         emit_keyword
-        visit_plain(condition)
+        visit(condition)
       end
 
     end # Repetition