unparser 0.6.5 → 0.8.0

data/lib/unparser/writer/dynamic_string.rb

@@ -5,128 +5,123 @@ module Unparser
     class DynamicString
       include Writer, Adamantium
 
-      PATTERNS_2 =
-        [
-          %i[str_empty begin].freeze,
-          %i[begin str_nl].freeze
-        ].freeze
-
-      PATTERNS_3 =
-        [
-          %i[begin str_nl_eol str_nl_eol].freeze,
-          %i[str_nl_eol begin str_nl_eol].freeze,
-          %i[str_ws begin str_nl_eol].freeze
-        ].freeze
-
       FLAT_INTERPOLATION = %i[ivar cvar gvar nth_ref].to_set.freeze
 
-      private_constant(*constants(false))
-
-      def emit_heredoc_reminder
-        return unless heredoc?
+      # Amount of dstr children at which heredoc emitting is
+      # preferred, but not guaranteed.
+      HEREDOC_THRESHOLD = 8
+      HEREDOC_DELIMITER = 'HEREDOC'
+      HEREDOC_HEADER    = "<<-#{HEREDOC_DELIMITER}".freeze
+      HEREDOC_FOOTER    = "#{HEREDOC_DELIMITER}\n".freeze
 
-        emit_heredoc_body
-        emit_heredoc_footer
-      end
+      private_constant(*constants(false))
 
+      # The raise below is not reachable if unparser is correctly implemented
+      # but has to exist as I have to assume unparser still has bugs.
+      #
+      # But unless I had such a bug in my test corpus: I cannot enable mutant, and if I
+      # knew about such a bug: I'd fix it so would be back at the start.
+      #
+      # TLDR: Good case for a mutant disable.
+      #
+      # mutant:disable
       def dispatch
         if heredoc?
-          emit_heredoc_header
+          write(HEREDOC_HEADER)
+          buffer.push_heredoc(heredoc_body)
+        elsif round_tripping_segmented_source
+          write(round_tripping_segmented_source)
         else
-          emit_dstr
+          fail UnsupportedNodeError, "Unparser cannot round trip this node: #{node.inspect}"
         end
       end
 
     private
 
-      def heredoc_header
-        '<<-HEREDOC'
-      end
-
       def heredoc?
-        !children.empty? && (nl_last_child? && heredoc_pattern?)
+        if children.length >= HEREDOC_THRESHOLD
+          round_trips_heredoc?
+        else
+          round_tripping_segmented_source.nil? # && round_trips_heredoc?
+        end
       end
+      memoize :heredoc?
 
-      def emit_heredoc_header
-        write(heredoc_header)
+      def round_trips_heredoc?
+        round_trips?(source: heredoc_source)
       end
+      memoize :round_trips_heredoc?
 
-      def emit_heredoc_body
-        nl
-        emit_normal_heredoc_body
-      end
+      def round_tripping_segmented_source
+        each_segments(children) do |segments|
 
-      def emit_heredoc_footer
-        write('HEREDOC')
-      end
+          source = segmented_source(segments: segments)
 
-      def classify(node)
-        if n_str?(node)
-          classify_str(node)
-        else
-          node.type
+          return source if round_trips?(source: source)
         end
+        nil
       end
+      memoize :round_tripping_segmented_source
+
+      def each_segments(array)
+        yield [array]
 
-      def classify_str(node)
-        if str_nl?(node)
-          :str_nl
-        elsif node.children.first.end_with?("\n")
-          :str_nl_eol
-        elsif str_ws?(node)
-          :str_ws
-        elsif str_empty?(node)
-          :str_empty
+        1.upto(array.length) do |take|
+          prefix = [array.take(take)]
+          suffix = array.drop(take)
+          each_segments(suffix) do |items|
+            yield(prefix + items)
+          end
         end
       end
 
-      def str_nl?(node)
-        node.eql?(s(:str, "\n"))
-      end
+      def segmented_source(segments:)
+        buffer = Buffer.new
 
-      def str_empty?(node)
-        node.eql?(s(:str, ''))
-      end
+        Segmented.new(
+          buffer:,
+          comments:,
+          explicit_encoding:    nil,
+          local_variable_scope:,
+          node:,
+          segments:
+        ).dispatch
 
-      def str_ws?(node)
-        /\A( |\t)+\z/.match?(node.children.first)
+        buffer.content
       end
 
-      def heredoc_pattern?
-        heredoc_pattern_2? || heredoc_pattern_3?
-      end
+      def heredoc_body
+        buffer = Buffer.new
 
-      def heredoc_pattern_3?
-        children.each_cons(3).any? do |group|
-          PATTERNS_3.include?(group.map(&method(:classify)))
-        end
-      end
+        writer = Heredoc.new(
+          buffer:,
+          comments:,
+          explicit_encoding:    nil,
+          local_variable_scope:,
+          node:
+        )
 
-      def heredoc_pattern_2?
-        children.each_cons(2).any? do |group|
-          PATTERNS_2.include?(group.map(&method(:classify)))
-        end
+        writer.emit
+        buffer.content
       end
+      memoize :heredoc_body
 
-      def nl_last_child?
-        last = children.last
-        n_str?(last) && last.children.first[-1].eql?("\n")
+      def heredoc_source
+        "#{HEREDOC_HEADER}\n#{heredoc_body}"
       end
+      memoize :heredoc_source
 
-      def emit_squiggly_heredoc_body
-        buffer.indent
-        children.each do |child|
-          if n_str?(child)
-            write(escape_dynamic(child.children.first))
-          else
-            emit_dynamic(child)
-          end
+      class Heredoc
+        include Writer, Adamantium
+
+        def emit
+          emit_heredoc_body
+          write(HEREDOC_FOOTER)
         end
-        buffer.unindent
-      end
 
-      def emit_normal_heredoc_body
-        buffer.root_indent do
+      private
+
+        def emit_heredoc_body
           children.each do |child|
             if n_str?(child)
               write(escape_dynamic(child.children.first))
@@ -135,88 +130,74 @@ module Unparser
             end
           end
         end
-      end
 
-      def escape_dynamic(string)
-        string.gsub('#', '\#')
-      end
+        def escape_dynamic(string)
+          string.gsub('#', '\#')
+        end
 
-      def emit_dynamic(child)
-        if FLAT_INTERPOLATION.include?(child.type)
-          write('#')
-          visit(child)
-        elsif n_dstr?(child)
-          emit_body(child.children)
-        else
+        def emit_dynamic(child)
           write('#{')
           emit_dynamic_component(child.children.first)
           write('}')
         end
-      end
 
-      def emit_dynamic_component(node)
-        visit(node) if node
-      end
-
-      def emit_dstr
-        if children.empty?
-          write('%()')
-        else
-          segments.each_with_index do |children, index|
-            emit_segment(children, index)
-          end
+        def emit_dynamic_component(node)
+          visit(node) if node
         end
-      end
-
-      def breakpoint?(child, current)
-        last_type = current.last&.type
+      end # Heredoc
 
-        [
-          n_str?(child) && last_type.equal?(:str) && current.none?(&method(:n_begin?)),
-          last_type.equal?(:dstr),
-          n_dstr?(child) && last_type
-        ].any?
-      end
-
-      def segments
-        segments = []
+      class Segmented
+        include Writer, Adamantium
 
-        segments << current = []
+        include anima.add(:segments)
 
-        children.each do |child|
-          if breakpoint?(child, current)
-            segments << current = []
+        def dispatch
+          if children.empty?
+            write('%()')
+          else
+            segments.each_with_index { |segment, index| emit_segment(segment, index) }
           end
-
-          current << child
         end
 
-        segments
-      end
+      private
 
-      def emit_segment(children, index)
-        write(' ') unless index.zero?
+        def emit_segment(children, index)
+          write(' ') unless index.zero?
 
-        write('"')
-        emit_body(children)
-        write('"')
-      end
+          write('"')
+          emit_segment_body(children)
+          write('"')
+        end
 
-      def emit_body(children)
-        buffer.root_indent do
+        def emit_segment_body(children)
           children.each_with_index do |child, index|
-            if n_str?(child)
-              string = child.children.first
-              if string.eql?("\n") && children.fetch(index.pred).type.equal?(:begin)
-                write("\n")
-              else
-                write(string.inspect[1..-2])
-              end
-            else
-              emit_dynamic(child)
+            case child.type
+            when :begin
+              write('#{')
+              visit(child.children.first) if child.children.first
+              write('}')
+            when FLAT_INTERPOLATION
+              write('#')
+              visit(child)
+            when :str
+              visit_str(children, child, index)
+            when :dstr
+              emit_segment_body(child.children)
             end
           end
         end
+
+        def visit_str(children, child, index)
+          string = child.children.first
+
+          next_child = children.at(index.succ)
+
+          if next_child && next_child.type.equal?(:str)
+            write(string.gsub('"', '\\"'))
+          else
+            write(child.children.first.inspect[1..-2])
+          end
+        end
       end
     end # DynamicString
   end # Writer

data/lib/unparser/writer/regexp.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    # Writer for regexp literals
+    class Regexp
+      include Writer, Adamantium
+
+      CANDIDATES = [
+        ['/', '/'].freeze,
+        ['%r{', '}'].freeze
+      ].freeze
+
+      define_group(:body, 0..-2)
+
+      def dispatch
+        effective_writer.write_to_buffer
+      end
+
+    private
+
+      # mutant:disable
+      def effective_writer
+        CANDIDATES.each do |token_open, token_close|
+          source = render_with_delimiter(token_close:, token_open:)
+
+          next unless round_trips?(source:)
+
+          return writer_with(Effective, node:, token_close:, token_open:)
+        end
+
+        fail 'Could not find a round tripping solution for regexp'
+      end
+
+      class Effective
+        include Writer, Adamantium
+
+        include anima.add(:token_close, :token_open)
+
+        define_group(:body, 0..-2)
+
+        def dispatch
+          buffer.root_indent do
+            write(token_open)
+            body.each(&method(:emit_body))
+            write(token_close)
+            emit_options
+          end
+        end
+
+      private
+
+        def emit_body(node)
+          if n_begin?(node)
+            write('#{')
+            node.children.each(&method(:visit))
+            write('}')
+          elsif n_gvar?(node)
+            write('#')
+            write_regular(node.children.first.to_s)
+          else
+            write_regular(node.children.first)
+          end
+        end
+
+        def write_regular(string)
+          if string.length > 1 && string.start_with?("\n")
+            string.each_char do |char|
+              buffer.append_without_prefix(char.eql?("\n") ? '\c*' : char)
+            end
+          else
+            buffer.append_without_prefix(string)
+          end
+        end
+
+        def emit_options
+          write(children.last.children.join)
+        end
+      end
+
+      # mutant:disable
+      def render_with_delimiter(token_close:, token_open:)
+        buffer = Buffer.new
+
+        writer = Effective.new(
+          buffer:,
+          comments:,
+          explicit_encoding:,
+          local_variable_scope:,
+          node:,
+          token_close:,
+          token_open:
+        )
+
+        writer.dispatch
+        buffer.nl_flush_heredocs
+        buffer.content
+      end
+    end # Regexp
+  end # Emitter
+end # Unparser

data/lib/unparser/writer/resbody.rb

@@ -6,11 +6,21 @@ module Unparser
     class Resbody
       include Writer
 
+      OPERATORS = {
+        csend: '&.',
+        send:  '.'
+      }.freeze
+
       children :exception, :assignment, :body
 
       def emit_postcontrol
-        write(' rescue ')
-        visit(body)
+        if body
+          write(' rescue ')
+          visit(body)
+        else
+          nl
+          write('rescue')
+        end
       end
 
       def emit_regular
@@ -33,7 +43,31 @@ module Unparser
         return unless assignment
 
         write(' => ')
-        visit(assignment)
+
+        case assignment.type
+        when :send, :csend
+          write_send_assignment
+        when :indexasgn
+          write_index_assignment
+        else
+          visit(assignment)
+        end
+      end
+
+      def write_send_assignment
+        details = NodeDetails::Send.new(assignment)
+
+        visit(details.receiver)
+        write(OPERATORS.fetch(assignment.type))
+        write(details.non_assignment_selector)
+      end
+
+      def write_index_assignment
+        receiver, *indexes = assignment.children
+        visit(receiver)
+        write('[')
+        delimited(indexes)
+        write(']')
       end
     end # Resbody
   end # Writer

data/lib/unparser/writer/rescue.rb

@@ -20,13 +20,9 @@ module Unparser
         end
       end
 
-      def emit_heredoc_reminders
-        emitter(body).emit_heredoc_reminders
-      end
-
       def emit_postcontrol
-        visit(body)
-        writer_with(Resbody, rescue_body).emit_postcontrol
+        visit(body) if body
+        writer_with(Resbody, node: rescue_body).emit_postcontrol
       end
 
     private
@@ -36,7 +32,7 @@ module Unparser
       end
 
       def emit_rescue_body(node)
-        writer_with(Resbody, node).emit_regular
+        writer_with(Resbody, node:).emit_regular
       end
     end # Rescue
   end # Writer

data/lib/unparser/writer/send/unary.rb

@@ -12,13 +12,18 @@ module Unparser
 
         private_constant(*constants(false))
 
-        def dispatch
+        def dispatch # rubocop:disable Metrics/AbcSize
           name = selector
+          first_child = children.fetch(0)
 
-          write(MAP.fetch(name, name).to_s)
+          if n_flipflop?(first_child) || n_and?(first_child) || n_or?(first_child)
+            write 'not '
+          else
+            write(MAP.fetch(name, name).to_s)
 
-          if n_int?(receiver) && selector.equal?(:+@)
-            write('+')
+            if n_int?(receiver) && selector.equal?(:+@)
+              write('+')
+            end
           end
 
           visit(receiver)

data/lib/unparser/writer/send.rb

@@ -30,15 +30,10 @@ module Unparser
         write(details.string_selector)
       end
 
-      def emit_heredoc_reminders
-        emitter(receiver).emit_heredoc_reminders if receiver
-        arguments.each(&method(:emit_heredoc_reminder))
-      end
-
     private
 
       def effective_writer
-        writer_with(effective_writer_class, node)
+        writer_with(effective_writer_class, node:)
       end
       memoize :effective_writer
 
@@ -78,10 +73,6 @@ module Unparser
         parentheses { delimited(arguments) }
       end
 
-      def emit_heredoc_reminder(argument)
-        emitter(argument).emit_heredoc_reminders
-      end
-
       def avoid_clash?
         local_variable_clash? || parses_as_constant?
       end
@@ -91,9 +82,12 @@ module Unparser
       end
 
       def parses_as_constant?
-        test = Unparser.parse_either(selector.to_s).from_right do
-          fail InvalidNodeError.new("Invalid selector for send node: #{selector.inspect}", node)
-        end
+        test = Unparser
+          .parse_ast_either(selector.to_s)
+          .fmap(&:node)
+          .from_right do
+            fail InvalidNodeError.new("Invalid selector for send node: #{selector.inspect}", node)
+          end
 
         n_const?(test)
       end
@@ -105,7 +99,7 @@ module Unparser
 
       def emit_send_regular(node)
         if n_send?(node)
-          writer_with(Regular, node).dispatch
+          writer_with(Regular, node:).dispatch
         else
           visit(node)
         end

data/lib/unparser/writer.rb

@@ -4,12 +4,42 @@ module Unparser
   module Writer
     include Generation, NodeHelpers
 
+    # mutant:disable
     def self.included(descendant)
       descendant.class_eval do
-        include Anima.new(:buffer, :comments, :node, :local_variable_scope)
+        include Adamantium, Anima.new(:buffer, :comments, :explicit_encoding, :node, :local_variable_scope)
 
         extend DSL
       end
     end
+
+  private
+
+    # mutant:disable
+    def emitter(node)
+      Emitter.emitter(
+        buffer:               buffer,
+        comments:             comments,
+        explicit_encoding:    explicit_encoding,
+        local_variable_scope: local_variable_scope,
+        node:                 node
+      )
+    end
+
+    # mutant:disable
+    def round_trips?(source:)
+      parser = Unparser.parser
+      local_variable_scope.local_variables_for_node(node).each do |local_variable|
+        parser.declare_local_variable(local_variable)
+      end
+
+      buffer = Buffer.new
+      buffer.write_encoding(explicit_encoding) if explicit_encoding
+      buffer.write(source)
+
+      node.eql?(parser.parse(Unparser.buffer(buffer.content)))
+    rescue Parser::SyntaxError
+      false
+    end
   end # Writer
 end # Unparser