unparser 0.4.9 → 0.5.4

data/lib/unparser/emitter/range.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Range emitters
+    class Range < self
+      TOKENS = {
+        irange: '..',
+        erange: '...'
+      }.freeze
+
+      SYMBOLS = {
+        erange: :tDOT3,
+        irange: :tDOT2
+      }.freeze
+
+      def symbol_name
+        true
+      end
+
+      handle(*TOKENS.keys)
+
+      children :begin_node, :end_node
+
+    private
+
+      def dispatch
+        visit(begin_node) if begin_node
+        write(TOKENS.fetch(node.type))
+        visit(end_node) if end_node
+      end
+
+    end # Range
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/regexp.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for regexp literals
+    class Regexp < self
+      handle :regexp
+
+      define_group(:body, 0..-2)
+
+    private
+
+      def dispatch
+        parentheses('/', '/') do
+          body.each(&method(:emit_body))
+        end
+        emit_options
+      end
+
+      def emit_options
+        write(children.last.children.join)
+      end
+
+      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/repetition.rb

@@ -5,39 +5,29 @@ module Unparser
 
     # Emitter for postconditions
     class Post < self
-      include Unterminated
-
-      handle :while_post, :until_post
-
       children :condition, :body
 
       MAP = {
-        while_post: K_WHILE,
-        until_post: K_UNTIL
+        while_post: 'while',
+        until_post: 'until'
       }.freeze
 
       handle(*MAP.keys)
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
+    private
+
       def dispatch
         visit(body)
-        write(WS, MAP.fetch(node.type), WS)
+        write(' ', MAP.fetch(node.type), ' ')
         visit(condition)
       end
     end
 
-    # Base class for while and until emitters
+    # Emitter for while and until nodes
     class Repetition < self
-      include Terminated
-
       MAP = {
-        while: K_WHILE,
-        until: K_UNTIL
+        while: 'while',
+        until: 'until'
       }.freeze
 
       handle(*MAP.keys)
@@ -46,12 +36,6 @@ module Unparser
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         if postcontrol?
           emit_postcontrol
@@ -60,54 +44,30 @@ module Unparser
         end
       end
 
-      # Test if node must be emitted in postcontrol form
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
       def postcontrol?
-        return nil unless body # greez from falsyness
-
-        local_variable_scope.first_assignment_in_body_and_used_in_condition?(body, condition)
+        body && local_variable_scope.first_assignment_in?(body, condition)
       end
 
-      # Emit keyword
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_keyword
-        write(MAP.fetch(node.type), WS)
+        write(MAP.fetch(node.type), ' ')
       end
 
-      # Emit embedded
-      #
-      # @return [undefned]
-      #
-      # @api private
-      #
       def emit_normal
         emit_keyword
-        conditional_parentheses(condition.type.equal?(:block)) do
-          visit(condition)
+        visit(condition)
+        if body
+          emit_body(body)
+        else
+          nl
         end
-        emit_body
         k_end
       end
 
-      # Emit postcontrol
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_postcontrol
-        visit_plain(body)
+        visit(body)
         ws
         emit_keyword
-        visit_plain(condition)
+        visit(condition)
       end
 
     end # Repetition

data/lib/unparser/emitter/rescue.rb

@@ -4,109 +4,13 @@ module Unparser
   class Emitter
     # Emitter for rescue nodes
     class Rescue < self
-      include Unterminated
-
       handle :rescue
 
-      children :body, :rescue_body
-
-      define_group :rescue_bodies, 1..-2
-
-      EMBEDDED_TYPES = %i[block def defs kwbegin ensure].to_set.freeze
-
-      NOINDENT_STANDALONE_RESCUE = %i[root begin pair_rocket pair_colon lvasgn ivasgn].to_set.freeze
-
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        if standalone?
-          if NOINDENT_STANDALONE_RESCUE.include?(parent_type)
-            emit_standalone
-          else
-            indented { emit_standalone }
-          end
-        else
-          emit_embedded
-        end
-      end
-
-      # Test if rescue node ist standalone
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def standalone?
-        if parent_type.equal?(:ensure)
-          !parent.node.children.first.equal?(node)
-        else
-          !EMBEDDED_TYPES.include?(parent_type)
-        end
-      end
-
-      # Emit standalone form
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def emit_standalone
-        visit_plain(body)
-        ws
-        run(Resbody::Standalone, rescue_body)
+        emit_rescue_postcontrol(node)
       end
-
-      # Emit embedded form
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def emit_embedded
-        if body
-          visit_indented(body)
-        else
-          nl
-        end
-        rescue_bodies.each do |child|
-          run(Resbody::Embedded, child)
-        end
-        emit_else
-      end
-
-      # Emit else
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def emit_else
-        return unless else_branch
-
-        write(K_ELSE)
-        visit_indented(else_branch)
-      end
-
-      # Return else body
-      #
-      # @return [Parser::AST::Node]
-      #   if else body is present
-      #
-      # @return [nil]
-      #   otherwise
-      #
-      # @api private
-      #
-      def else_branch
-        children.last
-      end
-
     end # Rescue
   end # Emitter
 end # Unparser

data/lib/unparser/emitter/root.rb

@@ -4,8 +4,24 @@ module Unparser
   class Emitter
     # Root emitter a special case
     class Root < self
-      include Concord::Public.new(:node, :buffer, :comments)
+      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_eof_comments
+
+        nl if END_NL.include?(node.type) && !buffer.fresh_line?
+      end
     end # Root
   end # Emitter
 end # Unparser

data/lib/unparser/emitter/send.rb

@@ -3,236 +3,27 @@
 module Unparser
   class Emitter
     # Emitter for send
-    # ignore :reek:TooManyMethods
     class Send < self
+      handle :csend, :send
 
-      handle :send
-
-      ASSIGN_SUFFIX    = '='.freeze
-      INDEX_ASSIGN     = :'[]='
-      INDEX_REFERENCE  = :'[]'
-      NON_ASSIGN_RANGE = (0..-2).freeze
-
-      children :receiver, :selector
+      def emit_mlhs
+        writer.emit_mlhs
+      end
 
-      def terminated?
-        effective_emitter.terminated?
+      def emit_heredoc_reminders
+        writer.emit_heredoc_reminders
       end
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        effective_emitter.write_to_buffer
-      end
-
-      # Return effective emitter
-      #
-      # @return [Emitter]
-      #
-      # @api private
-      #
-      def effective_emitter
-        effective_emitter_class.new(node, parent)
-      end
-
-      # Return effective emitter
-      #
-      # @return [Class:Emitter]
-      #
-      # @api private
-      #
-      def effective_emitter_class
-        if binary_operator?
-          Binary
-        elsif unary_operator?
-          Unary
-        elsif attribute_assignment?
-          AttributeAssignment
-        else
-          Regular
-        end
-      end
-
-      # Return string selector
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def string_selector
-        selector.to_s
-      end
-
-      # Test for unary operator implemented as method
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def unary_operator?
-        UNARY_OPERATORS.include?(selector)
-      end
-
-      # Test for binary operator implemented as method
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def binary_operator?
-        BINARY_OPERATORS.include?(selector) && arguments.one? && !arguments.first.type.equal?(:splat)
-      end
-
-      # Emit selector
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def emit_selector
-        write(mlhs? ? non_assignment_selector : string_selector)
-      end
-
-      # Test for mlhs
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def mlhs?
-        parent_type.equal?(:mlhs)
-      end
-
-      # Test for assignment
-      #
-      # FIXME: This also returns true for <= operator!
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def assignment?
-        string_selector[-1].eql?(ASSIGN_SUFFIX)
-      end
-
-      # Test for attribute assignment
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def attribute_assignment?
-        !BINARY_OPERATORS.include?(selector) && !UNARY_OPERATORS.include?(selector) && assignment? && !mlhs?
-      end
-
-      # Test for empty arguments
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def arguments?
-        arguments.any?
-      end
-
-      # Return argument nodes
-      #
-      # @return [Array<Parser::AST::Node>]
-      #
-      # @api private
-      #
-      def arguments
-        children[2..-1]
-      end
-      memoize :arguments
-
-      # Emit arguments
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def emit_arguments
-        if arguments.empty?
-          write('()') if receiver.nil? && avoid_clash?
-        else
-          normal_arguments
-        end
-      end
-
-      # Emit normal arguments
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def normal_arguments
-        parentheses do
-          delimited_plain(effective_arguments)
-        end
-      end
-
-      # The effective arguments
-      #
-      # @return [Parser::AST::Node]
-      #
-      # @api private
-      #
-      def effective_arguments
-        last = arguments.length - 1
-        arguments.each_with_index.map do |argument, index|
-          if last.equal?(index) && argument.type.equal?(:hash) && argument.children.any?
-            argument.updated(:hash_body)
-          else
-            argument
-          end
-        end
-      end
-
-      # Test if clash with local variable or constant needs to be avoided
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def avoid_clash?
-        local_variable_clash? || parses_as_constant?
-      end
-
-      # Test for local variable clash
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def local_variable_clash?
-        local_variable_scope.local_variable_defined_for_node?(node, selector)
-      end
-
-      # The non assignment selector
-      #
-      # @return [String]
-      #
-      # @api private
-      def non_assignment_selector
-        string_selector[NON_ASSIGN_RANGE]
+        writer.dispatch
       end
 
-      # Test if selector parses as constant
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
-      def parses_as_constant?
-        Unparser.parse(selector.to_s).type.equal?(:const)
+      def writer
+        writer_with(Writer::Send, node)
       end
+      memoize :writer
     end # Send
   end # Emitter
 end # Unparser