unparser 0.4.7 → 0.6.7

data/lib/unparser/writer/dynamic_string.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    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
+
+      private_constant(*constants(false))
+
+      def emit_heredoc_reminder
+        return unless heredoc?
+
+        emit_heredoc_body
+        emit_heredoc_footer
+      end
+
+      def dispatch
+        if heredoc?
+          emit_heredoc_header
+        else
+          emit_dstr
+        end
+      end
+
+    private
+
+      def heredoc_header
+        '<<-HEREDOC'
+      end
+
+      def heredoc?
+        !children.empty? && (nl_last_child? && heredoc_pattern?)
+      end
+
+      def emit_heredoc_header
+        write(heredoc_header)
+      end
+
+      def emit_heredoc_body
+        nl
+        emit_normal_heredoc_body
+      end
+
+      def emit_heredoc_footer
+        write('HEREDOC')
+      end
+
+      def classify(node)
+        if n_str?(node)
+          classify_str(node)
+        else
+          node.type
+        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 str_nl?(node)
+        node.eql?(s(:str, "\n"))
+      end
+
+      def str_empty?(node)
+        node.eql?(s(:str, ''))
+      end
+
+      def str_ws?(node)
+        /\A( |\t)+\z/.match?(node.children.first)
+      end
+
+      def heredoc_pattern?
+        heredoc_pattern_2? || heredoc_pattern_3?
+      end
+
+      def heredoc_pattern_3?
+        children.each_cons(3).any? do |group|
+          PATTERNS_3.include?(group.map(&method(:classify)))
+        end
+      end
+
+      def heredoc_pattern_2?
+        children.each_cons(2).any? do |group|
+          PATTERNS_2.include?(group.map(&method(:classify)))
+        end
+      end
+
+      def nl_last_child?
+        last = children.last
+        n_str?(last) && last.children.first[-1].eql?("\n")
+      end
+
+      def emit_normal_heredoc_body
+        buffer.root_indent do
+          children.each do |child|
+            if n_str?(child)
+              write(escape_dynamic(child.children.first))
+            else
+              emit_dynamic(child)
+            end
+          end
+        end
+      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
+          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
+        end
+      end
+
+      def breakpoint?(child, current)
+        last_type = current.last&.type
+
+        [
+          n_str?(child) && last_type.equal?(:str) && current.none?(&method(:n_begin?)),
+          last_type.equal?(:dstr),
+          n_dstr?(child) && last_type
+        ].any?
+      end
+
+      def segments
+        segments = []
+
+        segments << current = []
+
+        children.each do |child|
+          if breakpoint?(child, current)
+            segments << current = []
+          end
+
+          current << child
+        end
+
+        segments
+      end
+
+      def emit_segment(children, index)
+        write(' ') unless index.zero?
+
+        write('"')
+        emit_body(children)
+        write('"')
+      end
+
+      def emit_body(children)
+        buffer.root_indent do
+          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)
+            end
+          end
+        end
+      end
+    end # DynamicString
+  end # Writer
+end # Unparser

data/lib/unparser/writer/resbody.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    # Writer for rescue bodies
+    class Resbody
+      include Writer
+
+      children :exception, :assignment, :body
+
+      def emit_postcontrol
+        write(' rescue ')
+        visit(body)
+      end
+
+      def emit_regular
+        write('rescue')
+        emit_exception
+        emit_assignment
+        emit_optional_body(body)
+      end
+
+    private
+
+      def emit_exception
+        return unless exception
+
+        ws
+        delimited(exception.children)
+      end
+
+      def emit_assignment
+        return unless assignment
+
+        write(' => ')
+        visit(assignment)
+      end
+    end # Resbody
+  end # Writer
+end # Unparser

data/lib/unparser/writer/rescue.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Rescue
+      include Writer, Adamantium
+
+      children :body, :rescue_body
+
+      define_group :rescue_bodies, 1..-2
+
+      def emit_regular
+        emit_optional_body(body)
+
+        rescue_bodies.each(&method(:emit_rescue_body))
+
+        if else_node
+          write('else')
+          emit_body(else_node)
+        end
+      end
+
+      def emit_heredoc_reminders
+        emitter(body).emit_heredoc_reminders
+      end
+
+      def emit_postcontrol
+        visit(body)
+        writer_with(Resbody, rescue_body).emit_postcontrol
+      end
+
+    private
+
+      def else_node
+        children.last
+      end
+
+      def emit_rescue_body(node)
+        writer_with(Resbody, node).emit_regular
+      end
+    end # Rescue
+  end # Writer
+end # Unparser

data/lib/unparser/{emitter → writer}/send/attribute_assignment.rb

@@ -1,24 +1,16 @@
 # frozen_string_literal: true
 
 module Unparser
-  class Emitter
+  module Writer
     class Send
-      # Emitter for send as attribute assignment
+      # Writer for send as attribute assignment
       class AttributeAssignment < self
-        include Unterminated
-
         children :receiver, :selector, :first_argument
 
-        # Perform regular dispatch
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
         def dispatch
           emit_receiver
           emit_attribute
-          write(T_ASN)
+          write('=')
 
           if arguments.one?
             visit(first_argument)
@@ -27,29 +19,22 @@ module Unparser
           end
         end
 
+        def emit_send_mlhs
+          emit_receiver
+          write(details.non_assignment_selector)
+        end
+
       private
 
-        # Emit receiver
-        #
-        # @return [Parser::AST::Node]
-        #
-        # @api private
-        #
         def emit_receiver
           visit(receiver)
-          write(T_DOT)
+          emit_operator
         end
 
-        # Emit attribute
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
         def emit_attribute
-          write(non_assignment_selector)
+          write(details.non_assignment_selector)
         end
       end # AttributeAssignment
     end # Send
-  end # Emitter
+  end # Writer
 end # Unparser

data/lib/unparser/writer/send/binary.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Send
+      # Writer for binary sends
+      class Binary < self
+        def dispatch
+          visit(receiver)
+          emit_operator
+          emit_right
+        end
+
+      private
+
+        def emit_operator
+          write(' ', details.string_selector, ' ')
+        end
+
+        def emit_right
+          emit_send_regular(children.fetch(2))
+        end
+
+      end # Binary
+    end # Send
+  end # Writer
+end # Unparser

data/lib/unparser/writer/send/conditional.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Send
+      # Writer for "conditional" receiver&.selector(arguments...) case
+      class Conditional < self
+
+      private
+
+        def dispatch
+          emit_receiver
+          emit_selector
+          emit_arguments
+        end
+
+        def emit_receiver
+          visit(receiver)
+          write('&.')
+        end
+
+      end # Regular
+    end # Send
+  end # Writer
+end # Unparser

data/lib/unparser/writer/send/regular.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Send
+      # Writer for "regular" receiver.selector(arguments...) case
+      class Regular < self
+        def dispatch
+          emit_receiver
+          emit_selector
+          emit_arguments
+        end
+
+        def emit_send_mlhs
+          dispatch
+        end
+
+        def emit_arguments_without_heredoc_body
+          emit_normal_arguments if arguments.any?
+        end
+
+        def emit_receiver
+          return unless receiver
+
+          emit_send_regular(receiver)
+
+          emit_operator
+        end
+
+      end # Regular
+    end # Send
+  end # Writer
+end # Unparser

data/lib/unparser/{emitter → writer}/send/unary.rb

@@ -1,36 +1,29 @@
 # frozen_string_literal: true
 
 module Unparser
-  class Emitter
+  module Writer
     class Send
-      # Emitter for unary sends
+      # Writer for unary sends
       class Unary < self
-        include Unterminated
-
-      private
-
-        MAP = IceNine.deep_freeze(
+        MAP = {
           '-@': '-',
           '+@': '+'
-        )
+        }.freeze
+
+        private_constant(*constants(false))
 
-        # Perform dispatch
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
         def dispatch
           name = selector
+
           write(MAP.fetch(name, name).to_s)
-          if receiver.type.equal?(:int) && selector.equal?(:'+@')
+
+          if n_int?(receiver) && selector.equal?(:+@)
             write('+')
           end
 
           visit(receiver)
         end
-
       end # Unary
     end # Send
-  end # Emitter
+  end # Writer
 end # Unparser

data/lib/unparser/writer/send.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    # Writer for send
+    class Send
+      include Writer, Adamantium, Constants, Generation
+
+      INDEX_ASSIGN    = :[]=
+      INDEX_REFERENCE = :[]
+
+      OPERATORS = {
+        csend: '&.',
+        send:  '.'
+      }.freeze
+
+      private_constant(*constants(false))
+
+      children :receiver, :selector
+
+      def dispatch
+        effective_writer.dispatch
+      end
+
+      def emit_mlhs
+        effective_writer.emit_send_mlhs
+      end
+
+      def emit_selector
+        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)
+      end
+      memoize :effective_writer
+
+      def effective_writer_class
+        if details.binary_syntax_allowed?
+          Binary
+        elsif details.selector_unary_operator? && n_send?(node) && arguments.empty?
+          Unary
+        elsif write_as_attribute_assignment?
+          AttributeAssignment
+        else
+          Regular
+        end
+      end
+
+      def write_as_attribute_assignment?
+        details.assignment_operator?
+      end
+
+      def emit_operator
+        write(OPERATORS.fetch(node.type))
+      end
+
+      def emit_arguments
+        if arguments.empty?
+          write('()') if receiver.nil? && avoid_clash?
+        else
+          emit_normal_arguments
+        end
+      end
+
+      def arguments
+        details.arguments
+      end
+
+      def emit_normal_arguments
+        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
+
+      def local_variable_clash?
+        local_variable_scope.local_variable_defined_for_node?(node, selector)
+      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
+
+        n_const?(test)
+      end
+
+      def details
+        NodeDetails::Send.new(node)
+      end
+      memoize :details
+
+      def emit_send_regular(node)
+        if n_send?(node)
+          writer_with(Regular, node).dispatch
+        else
+          visit(node)
+        end
+      end
+    end # Send
+  end # Writer
+end # Unparser

data/lib/unparser/writer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    include Generation, NodeHelpers
+
+    def self.included(descendant)
+      descendant.class_eval do
+        include Anima.new(:buffer, :comments, :node, :local_variable_scope)
+
+        extend DSL
+      end
+    end
+  end # Writer
+end # Unparser