unparser 0.6.7 → 0.9.0

data/lib/unparser/either.rb

@@ -19,11 +19,13 @@ module Unparser
   end # RequireBLock
 
   class Either
-    include(
-      Adamantium,
-      Concord.new(:value),
-      RequireBlock
-    )
+    include Adamantium, Equalizer.new(:value), RequireBlock
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
 
     # Execute block and wrap error in left
     #
@@ -54,15 +56,15 @@ module Unparser
       # Evaluate functor block
       #
       # @return [Either::Left<Object>]
-      def fmap(&block)
-        require_block(&block)
+      def fmap(&)
+        require_block(&)
       end
 
       # Evaluate applicative block
       #
       # @return [Either::Left<Object>]
-      def bind(&block)
-        require_block(&block)
+      def bind(&)
+        require_block(&)
       end
 
       # Unwrap value from left
@@ -137,8 +139,8 @@ module Unparser
       # Map over left value
       #
       # @return [Either::Right<Object>]
-      def lmap(&block)
-        require_block(&block)
+      def lmap(&)
+        require_block(&)
       end
 
       # Evaluate right side of branch

data/lib/unparser/emitter/args.rb

@@ -13,7 +13,11 @@ module Unparser
       end
 
       def emit_def_arguments
-        delimited(normal_arguments)
+        if children.one? && n_mlhs?(Util.one(children))
+          emitter(Util.one(children)).dispatch_def
+        else
+          delimited(normal_arguments)
+        end
       end
 
       def emit_lambda_arguments

data/lib/unparser/emitter/array.rb

@@ -6,10 +6,6 @@ module Unparser
     class Array < self
       handle :array
 
-      def emit_heredoc_reminders
-        emitters.each(&:emit_heredoc_reminders)
-      end
-
     private
 
       def dispatch

data/lib/unparser/emitter/array_pattern.rb

@@ -12,18 +12,10 @@ module Unparser
 
       def dispatch
         write('[')
-        delimited(children, &method(:emit_member))
+        delimited(children)
         write(', ') if node_type.equal?(:array_pattern_with_tail)
         write(']')
       end
-
-      def emit_member(node)
-        if n_match_rest?(node)
-          writer_with(MatchRest, node).emit_array_pattern
-        else
-          visit(node)
-        end
-      end
     end # Pin
   end # Emitter
 end # Unparser

data/lib/unparser/emitter/assignment.rb

@@ -11,12 +11,6 @@ module Unparser
         true
       end
 
-      def emit_heredoc_reminders
-        return unless right
-
-        emitter(right).emit_heredoc_reminders
-      end
-
     private
 
       def dispatch
@@ -30,12 +24,27 @@ module Unparser
         write(' = ')
 
         if BINARY_OPERATOR.include?(right.type)
-          writer_with(Writer::Binary, right).emit_operator
+          writer_with(Writer::Binary, node: right).emit_operator
+        elsif n_array?(right)
+          emit_array
+        else
+          right_emitter.write_to_buffer
+        end
+      end
+
+      def emit_array
+        if right.children.size > 1
+          delimited(right.children)
         else
-          visit(right)
+          right_emitter.write_to_buffer
         end
       end
 
+      def right_emitter
+        emitter(right)
+      end
+      memoize :right_emitter
+
       abstract_method :emit_left
 
       # Variable assignment emitter

data/lib/unparser/emitter/begin.rb

@@ -8,12 +8,6 @@ module Unparser
       handle :begin
       children :body
 
-      def emit_heredoc_reminders
-        children.each do |child|
-          emitter(child).emit_heredoc_reminders
-        end
-      end
-
     private
 
       def dispatch

data/lib/unparser/emitter/binary.rb

@@ -13,7 +13,7 @@ module Unparser
       end
 
       def writer
-        writer_with(Writer::Binary, node)
+        writer_with(Writer::Binary, node:)
       end
       memoize :writer
     end # Binary

data/lib/unparser/emitter/block.rb

@@ -5,7 +5,7 @@ module Unparser
 
     # Block emitter
     class Block < self
-      handle :block, :numblock
+      handle :block, :numblock, :itblock
 
       children :target, :arguments, :body
 
@@ -16,7 +16,6 @@ module Unparser
         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
@@ -42,7 +41,7 @@ module Unparser
       end
 
       def target_writer
-        writer_with(Writer::Send::Regular, target)
+        writer_with(Writer::Send::Regular, node: target)
       end
       memoize :target_writer
 
@@ -52,7 +51,7 @@ module Unparser
           emit_send_target
         when :lambda
           visit(target)
-          emit_lambda_arguments unless node.type.equal?(:numblock)
+          emit_lambda_arguments
         else
           visit(target)
         end
@@ -64,21 +63,33 @@ module Unparser
         target_writer.emit_arguments_without_heredoc_body
       end
 
+      # NOTE: mutant fails on Ruby < 3.4
+      # mutant:disable
       def emit_lambda_arguments
-        parentheses { writer_with(Args, arguments).emit_lambda_arguments }
+        return if node.type.equal?(:numblock) || itblock?
+
+        parentheses { writer_with(Args, node: arguments).emit_lambda_arguments }
       end
 
       def numblock?
         node.type.equal?(:numblock)
       end
 
+      # NOTE: mutant fails on Ruby < 3.4
+      # mutant:disable
+      def itblock?
+        node.type.equal?(:itblock)
+      end
+
+      # NOTE: mutant fails on Ruby < 3.4
+      # mutant:disable
       def emit_block_arguments
-        return if numblock? || arguments.children.empty?
+        return if numblock? || itblock? || arguments.children.empty?
 
         ws
 
         parentheses('|', '|') do
-          writer_with(Args, arguments).emit_block_arguments
+          writer_with(Args, node: arguments).emit_block_arguments
         end
       end
 

data/lib/unparser/emitter/def.rb

@@ -26,7 +26,7 @@ module Unparser
         return if arguments.children.empty?
 
         parentheses do
-          writer_with(Args, arguments).emit_def_arguments
+          writer_with(Args, node: arguments).emit_def_arguments
         end
       end
 

data/lib/unparser/emitter/dstr.rb

@@ -7,15 +7,16 @@ module Unparser
 
       handle :dstr
 
-      def emit_heredoc_reminders
-        writer_with(Writer::DynamicString, node).emit_heredoc_reminder
-      end
-
     private
 
       def dispatch
-        writer_with(Writer::DynamicString, node).dispatch
+        dstr_writer.dispatch
+      end
+
+      def dstr_writer
+        writer_with(Writer::DynamicString, node:)
       end
+      memoize :dstr_writer
 
     end # DStr
   end # Emitter

data/lib/unparser/emitter/dsym.rb

@@ -33,7 +33,7 @@ module Unparser
 
       def emit_begin_child(component)
         write('#{')
-        visit(unwrap_single_begin(component))
+        visit(Util.one(component.children)) if component.children.any?
         write('}')
       end
     end # DSym

data/lib/unparser/emitter/ensure.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for ensure nodes
+    class Ensure < self
+      handle :ensure
+
+    private
+
+      def dispatch
+        emit_ensure(node)
+      end
+    end # Ensure
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/flipflop.rb

@@ -25,9 +25,14 @@ module Unparser
     private
 
       def dispatch
-        visit(left)
+        visit(left) if left
         write(MAP.fetch(node.type))
-        visit(right)
+
+        if right
+          visit(right)
+        else
+          write(';')
+        end
       end
     end # FlipFLop
   end # Emitter

data/lib/unparser/emitter/flow_modifier.rb

@@ -14,12 +14,6 @@ module Unparser
 
       handle(*MAP.keys)
 
-      def emit_heredoc_reminders
-        children.each do |node|
-          emitter(node).emit_heredoc_reminders
-        end
-      end
-
     private
 
       def dispatch
@@ -27,7 +21,7 @@ module Unparser
 
         if children.one? && n_if?(children.first)
           ws
-          emitter(children.first).emit_ternary
+          emitter(Util.one(children)).emit_ternary
         else
           emit_arguments unless children.empty?
         end

data/lib/unparser/emitter/for.rb

@@ -18,7 +18,7 @@ module Unparser
       end
 
       def emit_condition
-        visit(condition)
+        emitter(condition).emit_mlhs
         write(' in ')
         visit(assignment)
         write(' do')

data/lib/unparser/emitter/hash.rb

@@ -6,10 +6,6 @@ module Unparser
     class Hash < self
       handle :hash
 
-      def emit_heredoc_reminders
-        children.each(&method(:emit_heredoc_reminder_member))
-      end
-
     private
 
       def dispatch
@@ -24,10 +20,6 @@ module Unparser
         end
       end
 
-      def emit_heredoc_reminder_member(node)
-        emitter(node.children.last).emit_heredoc_reminders
-      end
-
       def emit_hash_body
         delimited(children)
       end

data/lib/unparser/emitter/hash_pattern.rb

@@ -32,7 +32,7 @@ module Unparser
         when :match_var
           emit_match_var(node)
         when :match_rest
-          writer_with(MatchRest, node).emit_hash_pattern
+          writer_with(MatchRest, node:).emit_hash_pattern
         else
           visit(node)
         end

data/lib/unparser/emitter/in_pattern.rb

@@ -16,7 +16,7 @@ module Unparser
 
         ws
 
-        visit(target)
+        dispatch_target(target)
 
         if unless_guard
           ws
@@ -31,6 +31,14 @@ module Unparser
           nl
         end
       end
+
+      def dispatch_target(target)
+        if n_array?(target)
+          writer_with(Writer::Array, node: target).emit_compact
+        else
+          visit(target)
+        end
+      end
     end # InPattern
   end # Emitter
 end # Unparser

data/lib/unparser/emitter/index.rb

@@ -40,10 +40,6 @@ module Unparser
 
         private_constant(*constants(false))
 
-        def emit_heredoc_reminders
-          emitter(children.last).emit_heredoc_reminders
-        end
-
         def dispatch
           emit_receiver
           emit_operation(children[VALUE_RANGE])

data/lib/unparser/emitter/kwbegin.rb

@@ -12,7 +12,7 @@ module Unparser
         write('begin')
 
         if children.one?
-          emit_body_ensure_rescue(children.first)
+          emit_body_ensure_rescue(Util.one(children))
         else
           indented do
             emit_multiple_body

data/lib/unparser/emitter/match_pattern.rb

@@ -9,21 +9,17 @@ module Unparser
 
       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)
+        write(' => ')
+
+        if n_array?(pattern)
+          writer_with(Writer::Array, node: pattern).emit_compact
+        else
+          visit(pattern)
+        end
       end
     end # MatchPattern
   end # Emitter

data/lib/unparser/emitter/match_pattern_p.rb

@@ -13,7 +13,12 @@ module Unparser
       def dispatch
         visit(target)
         write(' in ')
-        visit(pattern)
+
+        if n_array?(pattern)
+          writer_with(Writer::Array, node: pattern).emit_compact
+        else
+          visit(pattern)
+        end
       end
     end # MatchPatternP
   end # Emitter

data/lib/unparser/emitter/mlhs.rb

@@ -6,10 +6,16 @@ module Unparser
     class MLHS < self
       handle :mlhs
 
-      NO_COMMA = %i[arg splat mlhs restarg].freeze
+      NO_COMMA = %i[arg splat restarg].freeze
 
       private_constant(*constants(false))
 
+      def dispatch_def
+        parentheses do
+          delimited(children)
+        end
+      end
+
     private
 
       def dispatch

data/lib/unparser/emitter/op_assign.rb

@@ -14,11 +14,6 @@ module Unparser
 
       handle(*MAP.keys)
 
-      def emit_heredoc_reminders
-        emitter(target).emit_heredoc_reminders
-        emitter(expression).emit_heredoc_reminders
-      end
-
     private
 
       def dispatch

data/lib/unparser/emitter/pair.rb

@@ -15,19 +15,45 @@ module Unparser
     private
 
       def dispatch
-        if colon?(key)
-          write(key.children.first.to_s, ': ')
+        if colon?
+          emit_colon
+          unless implicit_value_lvar? || implicit_value_send?
+            write(' ')
+            visit(value)
+          end
         else
           visit(key)
           write(' => ')
+          visit(value)
         end
-
-        visit(value)
       end
 
-      def colon?(key)
+      def colon?
         n_sym?(key) && BAREWORD.match?(key.children.first)
       end
+
+      def emit_colon
+        write(key.children.first.to_s, ':')
+      end
+
+      def key_value
+        key.children.first
+      end
+
+      def implicit_value_lvar?
+        n_lvar?(value) && value.children.first.equal?(key_value)
+      end
+
+      def implicit_value_send?
+        children = value.children
+
+        n_send?(value) \
+          && !key_value.end_with?('?') \
+          && !key_value.end_with?('!') \
+          && children.fetch(0).nil? \
+          && children.fetch(1).equal?(key_value) \
+          && children.at(2).nil?
+      end
     end
   end
 end

data/lib/unparser/emitter/primitive.rb

@@ -7,18 +7,16 @@ module Unparser
 
       children :value
 
-      # Emitter for primitives based on Object#inspect
-      class Inspect < self
+      class Symbol < self
 
-        handle :sym, :str
+        handle :sym
 
-      private
+        private
 
         def dispatch
           write(value.inspect)
         end
-
-      end # Inspect
+      end # Symbol
 
       # Emitter for complex literals
       class Complex < self

data/lib/unparser/emitter/range.rb

@@ -25,9 +25,30 @@ module Unparser
     private
 
       def dispatch
-        visit(begin_node) if begin_node
+        visit_begin_node(begin_node)
         write(TOKENS.fetch(node.type))
-        visit(end_node) if end_node
+        visit_end_node(end_node)
+      end
+
+      def visit_begin_node(node)
+        return unless node
+
+        if n_array?(begin_node)
+          writer_with(Writer::Array, node: begin_node).emit_compact
+        else
+          visit(begin_node)
+        end
+      end
+
+      def visit_end_node(node)
+        return unless node
+
+        write(' ') if n_range?(node)
+        if n_array?(node)
+          writer_with(Writer::Array, node: node).emit_compact
+        else
+          visit(node)
+        end
       end
 
     end # Range

data/lib/unparser/emitter/regexp.rb

@@ -4,32 +4,20 @@ module Unparser
   class Emitter
     # Emitter for regexp literals
     class Regexp < self
-      handle :regexp
 
-      define_group(:body, 0..-2)
+      handle :regexp
 
     private
 
       def dispatch
-        parentheses('/', '/') do
-          body.each(&method(:emit_body))
-        end
-        emit_options
+        writer.dispatch
       end
 
-      def emit_options
-        write(children.last.children.join)
+      def writer
+        writer_with(Writer::Regexp, node:)
       end
+      memoize :writer
 
-      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/rescue.rb

@@ -9,7 +9,13 @@ module Unparser
     private
 
       def dispatch
-        emit_rescue_postcontrol(node)
+        resbody = children.fetch(1)
+
+        if resbody.children.fetch(1)
+          emit_rescue_regular(node)
+        else
+          emit_rescue_postcontrol(node)
+        end
       end
     end # Rescue
   end # Emitter