unparser 0.6.7 → 0.9.0

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

@@ -41,6 +41,8 @@ module Unparser
         children.each do |child|
           if n_begin?(child)
             emit_begin(child)
+          elsif n_gvar?(child)
+            emit_gvar(child)
           else
             emit_string(child)
           end
@@ -64,9 +66,14 @@ module Unparser
 
       def emit_begin(component)
         write('#{')
-        visit(unwrap_single_begin(component))
+        visit(Util.one(component.children)) if component.children.any?
         write('}')
       end
+
+      def emit_gvar(component)
+        write('#')
+        write(Util.one(component.children).to_s)
+      end
     end # XStr
   end # Emitter
 end # Unparser

data/lib/unparser/emitter.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module Unparser
-  UnknownNodeError = Class.new(ArgumentError)
+  class UnknownNodeError < ArgumentError
+  end
 
   # 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 +23,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 +67,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 +75,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 +91,5 @@ module Unparser
     # @api private
     #
     abstract_method :dispatch
-
   end # Emitter
 end # Unparser

data/lib/unparser/equalizer.rb

@@ -4,95 +4,129 @@ module Unparser
   # Define equality, equivalence and inspection methods
   #
   # Original code before vendoring and reduction from: https://github.com/dkubb/equalizer.
-  class Equalizer < Module
-    # Initialize an Equalizer with the given keys
+  module Equalizer
+    # Creates a module providing equality methods based on the given attributes
     #
-    # Will use the keys with which it is initialized to define #cmp?,
-    # #hash, and #inspect
+    # @param keys [Array<Symbol>] attribute names to use for equality
+    # @param inspect [Boolean] whether to override #inspect and #pretty_print
+    # @return [Module] a module to include in your class
+    # @raise [ArgumentError] if keys is empty or contains non-Symbols
     #
-    # @param [Array<Symbol>] keys
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    # rubocop:disable Lint/MissingSuper
-    def initialize(*keys)
-      @keys = keys
-      define_methods
-      freeze
-    end
-    # rubocop:enable Lint/MissingSuper
-
-    private
-
-    def included(descendant)
-      descendant.include(Methods)
-    end
-
-    def define_methods
-      define_cmp_method
-      define_hash_method
-      define_inspect_method
+    # @api public
+    def self.new(*keys, inspect: true)
+      build_module(keys.freeze, inspect:)
     end
 
-    def define_cmp_method
-      keys = @keys
-      define_method(:cmp?) do |comparator, other|
-        keys.all? do |key|
-          __send__(key).public_send(comparator, other.__send__(key))
-        end
+    # Instance methods mixed into classes that include an Equalizer module
+    #
+    # @api private
+    module InstanceMethods
+      # Equality comparison allowing subclasses
+      #
+      # @param other [Object] object to compare
+      # @return [Boolean] true if other is_a? same class with equal attributes
+      def ==(other)
+        other.is_a?(self.class) &&
+          cmp?(:==, other)
       end
-      private :cmp?
-    end
 
-    def define_hash_method
-      keys = @keys
-      define_method(:hash) do
-        keys.map(&public_method(:__send__)).push(self.class).hash
+      # Strict equality requiring exact class match
+      #
+      # @param other [Object] object to compare
+      # @return [Boolean] true if other is exact same class with eql? attributes
+      def eql?(other)
+        other.instance_of?(self.class) &&
+          cmp?(:eql?, other)
       end
-    end
 
-    def define_inspect_method
-      keys = @keys
-      define_method(:inspect) do
-        klass = self.class
-        name  = klass.name || klass.inspect
-        "#<#{name}#{keys.map { |key| " #{key}=#{__send__(key).inspect}" }.join}>"
+      # Hash code based on class and attribute values
+      #
+      # @return [Integer] hash code
+      def hash
+        [self.class, *deconstruct].hash
       end
-    end
 
-    # The comparison methods
-    module Methods
-      # Compare the object with other object for equality
+      # Array deconstruction for pattern matching
       #
-      # @example
-      #   object.eql?(other)  # => true or false
+      # @return [Array] attribute values in order
+      def deconstruct
+        equalizer_keys.map { |key| public_send(key) }
+      end
+
+      # Hash deconstruction for pattern matching
       #
-      # @param [Object] other
-      #   the other object to compare with
+      # @param requested [Array<Symbol>, nil] keys to include, or nil for all
+      # @return [Hash{Symbol => Object}] requested attribute key-value pairs
+      def deconstruct_keys(requested)
+        subset = requested.nil? ? equalizer_keys : equalizer_keys & requested
+        subset.to_h { |key| [key, public_send(key)] }
+      end
+
+      private
+
+      # Compare all attributes using the given comparator
       #
-      # @return [Boolean]
+      # @param comparator [Symbol] method to use for comparison
+      # @param other [Object] object to compare against
+      # @return [Boolean] true if all attributes match
       #
-      # @api public
-      def eql?(other)
-        instance_of?(other.class) && cmp?(__method__, other)
+      # @api private
+      def cmp?(comparator, other)
+        equalizer_keys.all? do |key|
+          public_send(key)
+            .public_send(comparator, other.public_send(key))
+        end
       end
+    end
 
-      # Compare the object with other object for equivalency
-      #
-      # @example
-      #   object == other  # => true or false
+    # Instance methods for inspect and pretty print output
+    #
+    # @api private
+    module InspectMethods
+      # String representation showing only equalizer attributes
       #
-      # @param [Object] other
-      #   the other object to compare with
+      # @return [String] inspect output
+      def inspect
+        attrs = equalizer_keys
+          .map { |key| "@#{key}=#{public_send(key).inspect}" }
+          .join(', ')
+        Object.instance_method(:to_s).bind_call(self).sub(/>\z/, " #{attrs}>")
+      end
+
+      # Pretty print output using PP's object formatting
       #
-      # @return [Boolean]
+      # @param q [PP] pretty printer
+      # @return [void]
+      def pretty_print(pretty_printer)
+        pretty_printer.pp_object(self)
+      end
+
+      # Instance variables to display in pretty print output
       #
-      # @api public
-      def ==(other)
-        instance_of?(other.class) && cmp?(__method__, other)
+      # @return [Array<Symbol>] instance variable names
+      def pretty_print_instance_variables
+        equalizer_keys.map { |key| :"@#{key}" }
       end
-    end # module Methods
-  end # class Equalizer
+    end
+
+    # Builds the module with equality methods for the given keys
+    #
+    # @param keys [Array<Symbol>] attribute names (frozen)
+    # @param inspect [Boolean] whether to include inspect methods
+    # @return [Module] the configured module
+    #
+    # @api private
+    def self.build_module(keys, inspect:)
+      Module.new do
+        include InstanceMethods
+        include InspectMethods if inspect
+
+        set_temporary_name("Equalizer(#{keys.join(', ')})")
+
+        define_method(:equalizer_keys) { keys }
+        private :equalizer_keys
+      end
+    end
+    private_class_method :build_module
+  end # module Equalizer
 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

@@ -20,6 +20,7 @@ module Unparser
 
       def binary_syntax_allowed?
         selector_binary_operator? \
+          && n_send?(node) \
           && arguments.one? \
           && !n_splat?(arguments.first) \
           && !n_kwargs?(arguments.first)

data/lib/unparser/node_details.rb

@@ -4,9 +4,16 @@ module Unparser
   module NodeDetails
     include Constants, NodeHelpers
 
+    # mutant:disable
     def self.included(descendant)
       descendant.class_eval do
-        include Adamantium, Concord.new(:node)
+        include Adamantium, Equalizer.new(:node)
+
+        attr_reader :node
+
+        def initialize(node)
+          @node = node
+        end
 
         extend DSL
       end

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,24 @@
+# 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
+    class SizeError < IndexError
+    end
+
+    # 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