unparser 0.6.7 → 0.9.0

data/lib/unparser/validation.rb

@@ -7,31 +7,38 @@ module Unparser
       :generated_node,
       :generated_source,
       :identification,
-      :original_node,
+      :original_ast,
       :original_source
     )
 
+    class PhaseException
+      include Anima.new(:exception, :phase)
+    end
+
     # Test if source could be unparsed successfully
     #
     # @return [Boolean]
     #
     # @api private
     #
+    # rubocop:disable Style/OperatorMethodCall
+    # mutant:disable
     def success?
       [
         original_source,
-        original_node,
+        original_ast,
         generated_source,
         generated_node
       ].all?(&:right?) && generated_node.from_right.==(original_node.from_right)
     end
+    # rubocop:enable Style/OperatorMethodCall
 
     # Return error report
     #
     # @return [String]
     #
     # @api private
-    #
+    # mutant:disable
     def report
       message = [identification]
 
@@ -45,48 +52,57 @@ module Unparser
     end
     memoize :report
 
+    # mutant:disable
+    def original_node
+      original_ast.fmap(&:node)
+    end
+
     # Create validator from string
     #
     # @param [String] original_source
     #
     # @return [Validator]
+    # mutant:disable
     def self.from_string(original_source)
-      original_node = Unparser
-        .parse_either(original_source)
+      original_ast = parse_ast_either(original_source)
 
-      generated_source = original_node
+      generated_source = original_ast
         .lmap(&method(:const_unit))
-        .bind(&Unparser.method(:unparse_either))
+        .bind(&method(:unparse_ast_either))
 
       generated_node = generated_source
         .lmap(&method(:const_unit))
-        .bind(&Unparser.method(:parse_either))
+        .bind(&method(:parse_ast_either))
+        .fmap(&:node)
 
       new(
-        identification:   '(string)',
-        original_source:  Either::Right.new(original_source),
-        original_node:    original_node,
+        generated_node:   generated_node,
         generated_source: generated_source,
-        generated_node:   generated_node
+        identification:   '(string)',
+        original_ast:     original_ast,
+        original_source:  Either::Right.new(original_source)
       )
     end
 
-    # Create validator from node
+    # Create validator from ast
     #
-    # @param [Parser::AST::Node] original_node
+    # @param [Unparser::AST] ast
     #
     # @return [Validator]
-    def self.from_node(original_node)
-      generated_source = Unparser.unparse_either(original_node)
+    #
+    # mutant:disable
+    def self.from_ast(ast:)
+      generated_source = Unparser.unparse_ast_either(ast)
 
       generated_node = generated_source
         .lmap(&method(:const_unit))
-        .bind(&Unparser.public_method(:parse_either))
+        .bind(&method(:parse_ast_either))
+        .fmap(&:node)
 
       new(
         identification:   '(string)',
         original_source:  generated_source,
-        original_node:    Either::Right.new(original_node),
+        original_ast:     Either::Right.new(ast),
         generated_source: generated_source,
         generated_node:   generated_node
       )
@@ -97,24 +113,45 @@ module Unparser
     # @param [Pathname] path
     #
     # @return [Validator]
+    #
+    # mutant:disable
     def self.from_path(path)
-      from_string(path.read).with(identification: path.to_s)
+      from_string(path.read.freeze).with(identification: path.to_s)
     end
 
+    # mutant:disable
+    def self.unparse_ast_either(ast)
+      Unparser.unparse_ast_either(ast)
+    end
+    private_class_method :unparse_ast_either
+
+    # mutant:disable
+    def self.parse_ast_either(source)
+      Unparser.parse_ast_either(source)
+    end
+    private_class_method :parse_ast_either
+
+    # mutant:disable
+    def self.const_unit(_); end
+    private_class_method :const_unit
+
   private
 
+    # mutant:disable
     def make_report(label, attribute_name)
       ["#{label}:"].concat(public_send(attribute_name).either(method(:report_exception), ->(value) { [value] }))
     end
 
-    def report_exception(exception)
-      if exception
-        [exception.inspect].concat(exception.backtrace.take(20))
+    # mutant:disable
+    def report_exception(phase_exception)
+      if phase_exception
+        [phase_exception.inspect].concat(phase_exception.backtrace&.take(20) || [])
       else
-        ['undefined']
+        %w[undefined]
       end
     end
 
+    # mutant:disable
     def node_diff_report
       diff = nil
 
@@ -130,14 +167,13 @@ module Unparser
       diff ? ['Node-Diff:', diff] : []
     end
 
-    def self.const_unit(_value); end
-    private_class_method :const_unit
-
     class Literal < self
+      # mutant:disable
       def success?
         original_source.eql?(generated_source)
       end
 
+      # mutant:disable
       def report
         message = [identification]
 
@@ -153,20 +189,26 @@ module Unparser
 
     private
 
+      # mutant:disable
       def source_diff_report
         diff = nil
 
         original_source.fmap do |original|
           generated_source.fmap do |generated|
             diff = Diff.new(
-              original.split("\n", -1),
-              generated.split("\n", -1)
+              encode(original).split("\n", -1),
+              encode(generated).split("\n", -1)
             ).colorized_diff
           end
         end
 
         diff ? ['Source-Diff:', diff] : []
       end
+
+      # mutant:disable
+      def encode(string)
+        string.encode('UTF-8', invalid: :replace, undef: :replace)
+      end
     end # Literal
   end # Validation
 end # Unparser

data/lib/unparser/writer/array.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Array
+      include Writer, Adamantium
+
+      MAP = {
+        dsym: '%I',
+        sym:  '%i',
+        dstr: '%W',
+        str:  '%w'
+      }.freeze
+      private_constant(*constants(false))
+
+      def emit_compact # rubocop:disable Metrics/AbcSize
+        children_generic_type = array_elements_generic_type
+
+        write(MAP.fetch(children_generic_type))
+
+        parentheses('[', ']') do
+          delimited(children, ' ') do |child|
+            if n_sym?(child) || n_str?(child)
+              write(Util.one(child.children).to_s)
+            else
+              write('#{')
+              emitter(Util.one(Util.one(child.children).children)).write_to_buffer
+              write('}')
+            end
+          end
+        end
+      end
+
+      private
+
+      def array_elements_generic_type
+        children_types = children.to_set(&:type)
+
+        if children_types == Set[:sym, :dsym]
+          :dsym
+        elsif children_types == Set[:str, :dstr]
+          :dstr
+        elsif children_types == Set[]
+          :sym
+        else
+          Util.one(children_types.to_a)
+        end
+      end
+    end # Array
+  end # Writer
+end # Unparser

data/lib/unparser/writer/binary.rb

@@ -39,7 +39,7 @@ module Unparser
           tANDOP: '&&'
         }.freeze
 
-      NEED_KEYWORD = %i[return break next].freeze
+      NEED_KEYWORD = %i[return break next match_pattern_p].freeze
 
       private_constant(*constants(false))
 
@@ -52,9 +52,13 @@ module Unparser
       end
 
       def dispatch
-        left_emitter.write_to_buffer
-        write(' ', MAP.fetch(effective_symbol), ' ')
-        visit(right)
+        if node.type.eql?(:and) && left.type.equal?(:or)
+          emit_with(KEYWORD_TOKENS)
+        else
+          left_emitter.write_to_buffer
+          write(' ', MAP.fetch(effective_symbol), ' ')
+          visit(right)
+        end
       end
 
     private

data/lib/unparser/writer/dynamic_string.rb

@@ -5,116 +5,122 @@ 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
 
+      # 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
+
       private_constant(*constants(false))
 
-      def emit_heredoc_reminder
-        return unless heredoc?
+      # 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
+        # Try predictable patterns first before exhaustive search
 
-        emit_heredoc_body
-        emit_heredoc_footer
-      end
+        # Pattern 1: HEREDOC for large dstr (>= 8 children, preserve readability)
+        return write_heredoc if children.length >= HEREDOC_THRESHOLD && round_trips_heredoc?
 
-      def dispatch
-        if heredoc?
-          emit_heredoc_header
-        else
-          emit_dstr
-        end
+        # Pattern 2: Limited search (prevent exponential blowup)
+        source = limited_search_segmented_source
+        return write(source) if source
+
+        # Pattern 3: HEREDOC fallback (last resort if segmentation fails)
+        return write_heredoc if round_trips_heredoc?
+
+        fail UnsupportedNodeError, "Unparser cannot round trip this node: #{node.inspect}"
       end
 
     private
 
-      def heredoc_header
-        '<<-HEREDOC'
+      def write_heredoc
+        write(HEREDOC_HEADER)
+        buffer.push_heredoc(heredoc_body)
       end
 
-      def heredoc?
-        !children.empty? && (nl_last_child? && heredoc_pattern?)
+      def round_trips_heredoc?
+        round_trips?(source: heredoc_source)
       end
+      memoize :round_trips_heredoc?
 
-      def emit_heredoc_header
-        write(heredoc_header)
-      end
+      def limited_search_segmented_source
+        each_segments(children) do |segments|
+          source = segmented_source(segments: segments)
+          return source if round_trips?(source: source)
+        end
 
-      def emit_heredoc_body
-        nl
-        emit_normal_heredoc_body
+        nil
       end
 
-      def emit_heredoc_footer
-        write('HEREDOC')
-      end
+      def each_segments(array)
+        yield [array]
 
-      def classify(node)
-        if n_str?(node)
-          classify_str(node)
-        else
-          node.type
+        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 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
-        end
-      end
+      def segmented_source(segments:)
+        buffer = Buffer.new
 
-      def str_nl?(node)
-        node.eql?(s(:str, "\n"))
-      end
+        Segmented.new(
+          buffer:,
+          comments:,
+          explicit_encoding:    nil,
+          local_variable_scope:,
+          node:,
+          segments:
+        ).dispatch
 
-      def str_empty?(node)
-        node.eql?(s(:str, ''))
+        buffer.content
       end
 
-      def str_ws?(node)
-        /\A( |\t)+\z/.match?(node.children.first)
-      end
+      def heredoc_body
+        buffer = Buffer.new
+
+        writer = Heredoc.new(
+          buffer:,
+          comments:,
+          explicit_encoding:    nil,
+          local_variable_scope:,
+          node:
+        )
 
-      def heredoc_pattern?
-        heredoc_pattern_2? || heredoc_pattern_3?
+        writer.emit
+        buffer.content
       end
+      memoize :heredoc_body
 
-      def heredoc_pattern_3?
-        children.each_cons(3).any? do |group|
-          PATTERNS_3.include?(group.map(&method(:classify)))
-        end
+      def heredoc_source
+        "#{HEREDOC_HEADER}\n#{heredoc_body}"
       end
+      memoize :heredoc_source
+
+      class Heredoc
+        include Writer, Adamantium
 
-      def heredoc_pattern_2?
-        children.each_cons(2).any? do |group|
-          PATTERNS_2.include?(group.map(&method(:classify)))
+        def emit
+          emit_heredoc_body
+          write(HEREDOC_FOOTER)
         end
-      end
 
-      def nl_last_child?
-        last = children.last
-        n_str?(last) && last.children.first[-1].eql?("\n")
-      end
+      private
 
-      def emit_normal_heredoc_body
-        buffer.root_indent do
+        def emit_heredoc_body
           children.each do |child|
             if n_str?(child)
               write(escape_dynamic(child.children.first))
@@ -123,88 +129,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
+      class Segmented
+        include Writer, Adamantium
 
-      def segments
-        segments = []
+        include anima.add(:segments)
 
-        segments << current = []
-
-        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