unparser 0.6.5 → 0.8.0

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
@@ -121,40 +119,50 @@ module Unparser
     end
 
     def emit_body(node, indent: true)
-      if indent
-        buffer.indent
-        nl
-      end
-
-      if n_begin?(node)
-        if node.children.one?
-          visit_deep(node)
+      with_indent(indent: indent) do
+        if n_begin?(node)
+          if node.children.empty?
+            write('()')
+          elsif node.children.one?
+            visit_deep(node)
+          else
+            emit_body_inner(node)
+          end
         else
-          emit_body_inner(node)
+          visit_deep(node)
         end
-      else
-        visit_deep(node)
       end
+    end
 
-      if indent
-        buffer.unindent
-        nl
-      end
+    def with_indent(indent:)
+      return yield unless indent
+
+      buffer.indent
+      nl
+      yield
+      buffer.unindent
+      nl
     end
 
     def emit_body_inner(node)
       head, *tail = node.children
       emit_body_member(head)
+      write(';') if requires_explicit_statement_terminator?(head, tail)
 
       tail.each do |child|
-        nl
+        buffer.ensure_nl
 
         nl if EXTRA_NL.include?(child.type)
 
         emit_body_member(child)
+        write(';') if requires_explicit_statement_terminator?(child, tail)
       end
     end
 
+    def requires_explicit_statement_terminator?(node, nodes_group)
+      n_range?(node) && node.children.fetch(1).nil? && !node.eql?(nodes_group.fetch(-1))
+    end
+
     def emit_body_member(node)
       if n_rescue?(node)
         emit_rescue_postcontrol(node)
@@ -204,21 +212,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)
@@ -226,10 +233,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/send.rb

@@ -19,9 +19,10 @@ module Unparser
       end
 
       def binary_syntax_allowed?
-        selector_binary_operator?        \
-          && arguments.one?              \
-          && !n_splat?(arguments.first)  \
+        selector_binary_operator? \
+          && n_send?(node) \
+          && arguments.one? \
+          && !n_splat?(arguments.first) \
           && !n_kwargs?(arguments.first)
       end
 

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/node_helpers.rb

@@ -31,7 +31,16 @@ module Unparser
       node.type.equal?(type)
     end
 
+    def n_flipflop?(node)
+      n_iflipflop?(node) || n_eflipflop?(node)
+    end
+
+    def n_range?(node)
+      n_irange?(node) || n_erange?(node)
+    end
+
     %i[
+      and
       arg
       args
       array
@@ -41,18 +50,26 @@ module Unparser
       cbase
       const
       dstr
+      eflipflop
       empty_else
+      erange
       ensure
+      gvar
       hash
       hash_pattern
       if
+      iflipflop
       in_pattern
       int
+      irange
       kwarg
       kwargs
       kwsplat
       lambda
+      lvar
       match_rest
+      mlhs
+      or
       pair
       rescue
       send
@@ -60,20 +77,13 @@ module Unparser
       splat
       str
       sym
-    ].each do |type|
+      xstr
+    ].to_set.each do |type|
       name = "n_#{type}?"
       define_method(name) do |node|
         n?(type, node)
       end
       private(name)
     end
-
-    def unwrap_single_begin(node)
-      if n_begin?(node) && node.children.one?
-        node.children.first
-      else
-        node
-      end
-    end
   end # NodeHelpers
 end # Unparser

data/lib/unparser/util.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Original code before vendoring and reduction from: https://github.com/mbj/mutant/blob/main/lib/mutant/util.rb
+  module Util
+    # Error raised by `Util.one` if size is not exactly one
+    SizeError = Class.new(IndexError)
+
+    # Return only element in array if it contains exactly one member
+    #
+    # @param array [Array]
+    #
+    # @return [Object] first entry
+    def self.one(array)
+      case array
+      in [value]
+        value
+      else
+        fail SizeError, "expected size to be exactly 1 but size was #{array.size}"
+      end
+    end
+  end
+end

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