unparser 0.6.15 → 0.8.0

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

data/lib/unparser.rb

@@ -3,7 +3,6 @@
 require 'diff/lcs'
 require 'diff/lcs/hunk'
 require 'optparse'
-require 'parser/current'
 require 'set'
 
 require 'unparser/equalizer'
@@ -18,18 +17,53 @@ require 'unparser/anima/attribute'
 require 'unparser/anima/error'
 
 # Library namespace
-module Unparser
+module Unparser # rubocop:disable Metrics/ModuleLength
   # Unparser specific AST builder defaulting to modern AST format
-  class Builder < Parser::Builders::Default
-    modernize
+  if Gem::Version.new(RUBY_VERSION) <= '3.4'
+    require 'parser/current'
+    class Builder < Parser::Builders::Default
+      modernize
 
-    def initialize
-      super
+      # mutant:disable
+      def initialize
+        super
 
-      self.emit_file_line_as_literals = false
+        self.emit_file_line_as_literals = false
+      end
+    end
+  else
+    require 'prism'
+    class Builder < Prism::Translation::Parser::Builder
+      modernize
+
+      # mutant:disable
+      def initialize
+        super
+
+        self.emit_file_line_as_literals = false
+      end
     end
   end
 
+  PARSER_CLASS =
+    if Gem::Version.new(RUBY_VERSION) <= '3.4'
+      Class.new(Parser::CurrentRuby) do
+        def declare_local_variable(local_variable)
+          static_env.declare(local_variable)
+        end
+      end
+    else
+      Class.new(Prism::Translation::Parser34) do
+        def declare_local_variable(local_variable)
+          (@local_variables ||= Set.new) << local_variable
+        end
+
+        def prism_options
+          super.merge(scopes: [@local_variables.to_a])
+        end
+      end
+    end
+
   EMPTY_STRING = ''.freeze
   EMPTY_ARRAY  = [].freeze
 
@@ -44,57 +78,118 @@ module Unparser
       @node = node
       freeze
     end
-  end
+  end # InvalidNodeError
+
+  # Error raised when unparser encounders AST it cannot generate source for that would parse to the same AST.
+  class UnsupportedNodeError < RuntimeError
+  end # UnsupportedNodeError
 
   # Unparse an AST (and, optionally, comments) into a string
   #
   # @param [Parser::AST::Node, nil] node
-  # @param [Array] comment_array
+  # @param [Array] comments
+  # @param [Encoding, nil] explicit_encoding
+  # @param [Set<Symbol>] static_local_variables
+  #
+  # @return [String]
+  #
+  # @raise InvalidNodeError
+  #   if the node passed is invalid
+  #
+  # @api public
+  #
+  # mutant:disable
+  # rubocop:disable Metrics/ParameterLists
+  def self.unparse(
+    node,
+    comments:               EMPTY_ARRAY,
+    explicit_encoding:      nil,
+    static_local_variables: Set.new
+  )
+    unparse_ast(
+      AST.new(
+        comments:               comments,
+        explicit_encoding:      explicit_encoding,
+        node:                   node,
+        static_local_variables: static_local_variables
+      )
+    )
+  end
+  # rubocop:enable Metrics/ParameterLists
+
+  # Unparse an AST
+  #
+  # @param [AST] ast
   #
   # @return [String]
   #
   # @raise InvalidNodeError
   #   if the node passed is invalid
   #
+  # @raise UnsupportedNodeError
+  #   if the node passed is valid but unparser cannot unparse it
+  #
   # @api public
-  def self.unparse(node, comment_array = [])
-    return '' if node.nil?
+  def self.unparse_ast(ast)
+    return EMPTY_STRING if ast.node.nil?
+
+    local_variable_scope = AST::LocalVariableScope.new(
+      node:                   ast.node,
+      static_local_variables: ast.static_local_variables
+    )
 
     Buffer.new.tap do |buffer|
       Emitter::Root.new(
-        buffer,
-        node,
-        Comments.new(comment_array)
+        buffer:               buffer,
+        comments:             Comments.new(ast.comments),
+        explicit_encoding:    ast.explicit_encoding,
+        local_variable_scope: local_variable_scope,
+        node:                 ast.node
       ).write_to_buffer
     end.content
   end
 
-  # Unparse with validation
+  # Unparse AST either
   #
-  # @param [Parser::AST::Node, nil] node
-  # @param [Array] comment_array
+  # @param [AST] ast
   #
-  # @return [Either<Validation,String>]
-  def self.unparse_validate(node, comment_array = [])
-    generated = unparse(node, comment_array)
-    validation = Validation.from_string(generated)
+  # @return [Either<Exception,String>]
+  def self.unparse_ast_either(ast)
+    Either.wrap_error(Exception) { unparse_ast(ast) }
+  end
+
+  # Unparse AST either
+  #
+  # @param [AST] ast
+  #
+  # @return [Either<Exception,String>]
+  #
+  # mutant:disable
+  def self.unparse_validate_ast_either(ast:)
+    validation = Validation.from_ast(ast:)
 
     if validation.success?
-      Either::Right.new(generated)
+      Either::Right.new(validation.generated_source.from_right)
     else
       Either::Left.new(validation)
     end
   end
 
-  # Unparse capturing errors
-  #
-  # This is mostly useful for writing testing tools against unparser.
+  # Unparse with validation
   #
   # @param [Parser::AST::Node, nil] node
+  # @param [Array] comments
   #
-  # @return [Either<Exception, String>]
-  def self.unparse_either(node)
-    Either.wrap_error(Exception) { unparse(node) }
+  # @return [Either<Validation,String>]
+  def self.unparse_validate(node, comments: EMPTY_ARRAY)
+    generated = unparse(node, comments:)
+    validation = Validation.from_string(generated)
+
+    if validation.success?
+      Either::Right.new(generated)
+    else
+      Either::Left.new(validation)
+    end
   end
 
   # Parse string into AST
@@ -103,27 +198,37 @@ module Unparser
   #
   # @return [Parser::AST::Node, nil]
   def self.parse(source)
-    parser.parse(buffer(source))
+    parse_ast(source).node
   end
 
   # Parse string into either syntax error or AST
   #
   # @param [String] source
   #
-  # @return [Either<Parser::SyntaxError, (Parser::ASTNode, nil)>]
-  def self.parse_either(source)
-    Either.wrap_error(Parser::SyntaxError) do
-      parser.parse(buffer(source))
+  # @return [Either<Exception, (Parser::ASTNode, nil)>]
+  def self.parse_ast_either(source)
+    Either.wrap_error(Exception) do
+      parse_ast(source)
     end
   end
 
-  # Parse string into AST, with comments
+  # Parse source with ast details
   #
   # @param [String] source
   #
-  # @return [Parser::AST::Node]
-  def self.parse_with_comments(source)
-    parser.parse_with_comments(buffer(source))
+  # @return [AST]
+  #
+  # mutant:disable
+  def self.parse_ast(source, static_local_variables: Set.new)
+    explicit_encoding = Parser::Source::Buffer.recognize_encoding(source.dup.force_encoding(Encoding::BINARY))
+    node, comments = parser.parse_with_comments(buffer(source))
+
+    AST.new(
+      comments:               comments,
+      explicit_encoding:      explicit_encoding,
+      node:                   node,
+      static_local_variables: static_local_variables
+    )
   end
 
   # Parser instance that produces AST unparser understands
@@ -131,8 +236,9 @@ module Unparser
   # @return [Parser::Base]
   #
   # @api private
+  # mutant:disable
   def self.parser
-    Parser::CurrentRuby.new(Builder.new).tap do |parser|
+    PARSER_CLASS.new(Builder.new).tap do |parser|
       parser.diagnostics.tap do |diagnostics|
         diagnostics.all_errors_are_fatal = true
       end
@@ -179,6 +285,7 @@ require 'unparser/emitter/def'
 require 'unparser/emitter/defined'
 require 'unparser/emitter/dstr'
 require 'unparser/emitter/dsym'
+require 'unparser/emitter/ensure'
 require 'unparser/emitter/flipflop'
 require 'unparser/emitter/float'
 require 'unparser/emitter/flow_modifier'
@@ -210,6 +317,7 @@ require 'unparser/emitter/rescue'
 require 'unparser/emitter/root'
 require 'unparser/emitter/send'
 require 'unparser/emitter/simple'
+require 'unparser/emitter/string'
 require 'unparser/emitter/splat'
 require 'unparser/emitter/super'
 require 'unparser/emitter/undef'
@@ -222,8 +330,10 @@ require 'unparser/emitter/find_pattern'
 require 'unparser/emitter/match_pattern'
 require 'unparser/emitter/match_pattern_p'
 require 'unparser/writer'
+require 'unparser/writer/array'
 require 'unparser/writer/binary'
 require 'unparser/writer/dynamic_string'
+require 'unparser/writer/regexp'
 require 'unparser/writer/resbody'
 require 'unparser/writer/rescue'
 require 'unparser/writer/send'
@@ -234,6 +344,7 @@ require 'unparser/writer/send/unary'
 require 'unparser/node_details'
 require 'unparser/node_details/send'
 require 'unparser/cli'
+require 'unparser/util'
 
 require 'unparser/validation'
 # make it easy for zombie