unparser 0.6.15 → 0.7.0

data/lib/unparser/emitter/primitive.rb

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

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

data/lib/unparser/emitter/root.rb

@@ -2,22 +2,15 @@
 
 module Unparser
   class Emitter
-    # Root emitter a special case
     class Root < self
-      include Concord::Public.new(:buffer, :node, :comments)
-      include LocalVariableRoot
-
       END_NL = %i[class sclass module begin].freeze
 
       private_constant(*constants(false))
 
       def dispatch
-        if children.any?
-          emit_body(node, indent: false)
-        else
-          visit_deep(node)
-        end
+        emit_body(node, indent: false)
 
+        buffer.nl_flush_heredocs
         emit_eof_comments
 
         nl if END_NL.include?(node.type) && !buffer.fresh_line?

data/lib/unparser/emitter/send.rb

@@ -10,10 +10,6 @@ module Unparser
         writer.emit_mlhs
       end
 
-      def emit_heredoc_reminders
-        writer.emit_heredoc_reminders
-      end
-
     private
 
       def dispatch
@@ -21,7 +17,7 @@ module Unparser
       end
 
       def writer
-        writer_with(Writer::Send, node)
+        writer_with(Writer::Send, node:)
       end
       memoize :writer
     end # Send

data/lib/unparser/emitter/string.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Base class for primitive emitters
+    class String < self
+      children :value
+
+      handle :str
+
+    private
+
+      def dispatch
+        if explicit_encoding && !value.encoding.equal?(explicit_encoding)
+          write_utf8_escaped
+        else
+          write(value.inspect)
+        end
+      end
+
+      def write_utf8_escaped
+        write('"')
+        value.each_codepoint do |codepoint|
+          write("\\u{#{codepoint.to_s(16)}}")
+        end
+        write('"')
+      end
+
+    end # String
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter.rb

@@ -6,7 +6,7 @@ module Unparser
   # Emitter base class
   class Emitter
     include Adamantium, AbstractType, Constants, Generation, NodeHelpers
-    include Anima.new(:buffer, :comments, :node, :local_variable_scope)
+    include Anima.new(:buffer, :comments, :explicit_encoding, :local_variable_scope, :node)
 
     public :node
 
@@ -22,10 +22,9 @@ module Unparser
       #
       # @return [Parser::AST::Node]
       #
-      # @api private
-      #
+      # mutant:disable
       def local_variable_scope
-        AST::LocalVariableScope.new(node)
+        AST::LocalVariableScope.new(node: node, static_local_variables: Set.new)
       end
 
       def self.included(descendant)
@@ -67,7 +66,7 @@ module Unparser
     # @api private
     #
     # rubocop:disable Metrics/ParameterLists
-    def self.emitter(buffer:, comments:, node:, local_variable_scope:)
+    def self.emitter(buffer:, explicit_encoding:, comments:, node:, local_variable_scope:)
       type = node.type
 
       klass = REGISTRY.fetch(type) do
@@ -75,10 +74,11 @@ module Unparser
       end
 
       klass.new(
-        buffer:               buffer,
-        comments:             comments,
-        local_variable_scope: local_variable_scope,
-        node:                 node
+        buffer:,
+        comments:,
+        explicit_encoding:,
+        local_variable_scope:,
+        node:
       )
     end
     # rubocop:enable Metrics/ParameterLists
@@ -90,6 +90,5 @@ module Unparser
     # @api private
     #
     abstract_method :dispatch
-
   end # Emitter
 end # Unparser

data/lib/unparser/generation.rb

@@ -7,8 +7,6 @@ module Unparser
 
     private_constant(*constants(false))
 
-    def emit_heredoc_reminders; end
-
     def symbol_name; end
 
     def write_to_buffer
@@ -151,7 +149,7 @@ module Unparser
       emit_body_member(head)
 
       tail.each do |child|
-        nl
+        buffer.ensure_nl
 
         nl if EXTRA_NL.include?(child.type)
 
@@ -208,21 +206,20 @@ module Unparser
     end
 
     def emit_rescue_postcontrol(node)
-      writer = writer_with(Writer::Rescue, node)
+      writer = writer_with(Writer::Rescue, node:)
       writer.emit_postcontrol
-      writer.emit_heredoc_reminders
     end
 
     def emit_rescue_regular(node)
-      writer_with(Writer::Rescue, node).emit_regular
+      writer_with(Writer::Rescue, node:).emit_regular
     end
 
-    def writer_with(klass, node)
-      klass.new(to_h.merge(node: node))
+    def emitter(node)
+      Emitter.emitter(**to_h, node: node)
     end
 
-    def emitter(node)
-      Emitter.emitter(**to_h.merge(node: node))
+    def writer_with(klass, node:, **attributes)
+      klass.new(to_h.merge(node: node, **attributes))
     end
 
     def visit(node)
@@ -230,10 +227,7 @@ module Unparser
     end
 
     def visit_deep(node)
-      emitter(node).tap do |emitter|
-        emitter.write_to_buffer
-        emitter.emit_heredoc_reminders
-      end
+      emitter(node).tap(&:write_to_buffer)
     end
 
     def first_child

data/lib/unparser/node_details.rb

@@ -4,6 +4,7 @@ module Unparser
   module NodeDetails
     include Constants, NodeHelpers
 
+    # mutant:disable
     def self.included(descendant)
       descendant.class_eval do
         include Adamantium, Concord.new(:node)

data/lib/unparser/validation.rb

@@ -7,10 +7,14 @@ 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]
@@ -18,10 +22,11 @@ module Unparser
     # @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)
@@ -33,7 +38,7 @@ module Unparser
     # @return [String]
     #
     # @api private
-    #
+    # mutant:disable
     def report
       message = [identification]
 
@@ -47,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
       )
@@ -99,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
 
@@ -132,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]
 
@@ -155,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