unparser 0.1.7 → 0.1.8

data/lib/unparser/constants.rb

@@ -4,17 +4,30 @@ module Unparser
   # All unparser constants maybe included in other libraries.
   module Constants
 
+    # Return frozen symbol set from enumerable
+    #
+    # @param [Enumerable]
+    #
+    # @return [Set<Symbol>]
+    #
+    # @api private
+    #
+    def self.symbol_set(enumerable)
+      enumerable.map(&:to_sym).freeze
+    end
+    private_class_method :symbol_set
+
     # All unary operators of the ruby language
-    UNARY_OPERATORS = %w(
+    UNARY_OPERATORS = symbol_set %w(
       ! ~ -@ +@
-    ).map(&:to_sym).to_set
+    )
 
     # All binary operators of the ruby language
-    BINARY_OPERATORS = %w(
+    BINARY_OPERATORS = symbol_set %w(
       + - * / & | && || << >> ==
       === != <= < <=> > >= =~ !~ ^
       ** %
-    ).map(&:to_sym).to_set
+    )
 
     COMMENT = '#'
 
@@ -89,12 +102,16 @@ module Unparser
     #
     # These nodes dont require parentheses to be exactly reproduced in context of a more complex expression.
     #
-    TERMINATED = %w(
+    TERMINATED = symbol_set %w(
       int float self kwbegin const regexp args lvar
       ivar gvar cvar if case module class sclass super
       yield zsuper break next defined? str block while loop until
       def defs true false nil array hash sym return
-    ).map(&:to_sym).to_set
+    )
+
+    DEFAULT_DELIMITER = ', '.freeze
+
+    CURLY_BRACKETS = IceNine.deep_freeze(%w({ }))
 
     KEYWORDS = constants.each_with_object([]) do |name, keywords|
       value = const_get(name).freeze

data/lib/unparser/emitter.rb

@@ -7,6 +7,30 @@ module Unparser
     include Adamantium::Flat, AbstractType, Constants, NodeHelpers
     include Concord.new(:node, :parent)
 
+    module LocalVariableRoot
+
+      # Return local variable root
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def local_variable_root
+        node
+      end
+
+    end
+
+    # Return local variable root
+    #
+    # @return [Parser::AST::Node]
+    #
+    # @api private
+    #
+    def local_variable_root
+      parent.local_variable_root
+    end
+
     # Registry for node emitters
     REGISTRY = {}
 
@@ -16,6 +40,14 @@ module Unparser
 
     CURLY_BRACKETS = IceNine.deep_freeze(%w({ }))
 
+    # Return assigned lvars
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api private
+    #
+    abstract_method :local_variables
+
     # Return node type
     #
     # @return [Symbol]

data/lib/unparser/emitter/argument.rb

@@ -30,6 +30,8 @@ module Unparser
 
       handle :args
 
+      SHADOWARGS = ->(node) { node.type == :shadowarg }.freeze
+
     private
 
       # Perform dispatch
@@ -39,16 +41,40 @@ module Unparser
       # @api private
       #
       def dispatch
-        mapped = children.map do |child|
+        delimited(normal_arguments)
+        unless shadowargs.empty?
+          write('; ')
+          delimited(shadowargs)
+        end
+      end
+
+      # Return normal arguments
+      #
+      # @return [Enumerable<Parser::AST::Node>]
+      #
+      # @api private
+      #
+      def normal_arguments
+        children.reject(&SHADOWARGS).map do |child|
           if child.type == :mlhs
             Parser::AST::Node.new(:arg_expr, [child])
           else
             child
           end
         end
-        delimited(mapped)
       end
 
+      # Return shadow args
+      #
+      # @return [Enumerable<Parser::AST::Node>]
+      #
+      # @api private
+      #
+      def shadowargs
+        children.select(&SHADOWARGS)
+      end
+      memoize :shadowargs
+
     end # Arguments
 
     # Emitter for block arguments
@@ -178,7 +204,7 @@ module Unparser
     # Argument emitter
     class Argument < self
 
-      handle :arg
+      handle :arg, :shadowarg
 
       children :name
 
@@ -213,7 +239,7 @@ module Unparser
       #
       def dispatch
         write(T_AMP)
-        visit(name)
+        visit_terminated(name)
       end
 
     end # BlockPass

data/lib/unparser/emitter/assignment.rb

@@ -90,6 +90,8 @@ module Unparser
 
         handle :masgn
 
+        PARENS = IceNine.deep_freeze(%w([ ]))
+
       private
 
         # Emit left
@@ -113,7 +115,10 @@ module Unparser
           right = children.last
           case right.type
           when :array
-            delimited(right.children)
+            children = right.children
+            parentheses(*PARENS) do
+              delimited(children)
+            end
           else
             visit(right)
           end
@@ -128,6 +133,8 @@ module Unparser
 
       private
 
+        NO_COMMA = [:splat, :restarg, :mlhs]
+
         # Perform dispatch
         #
         # @return [undefined]
@@ -138,6 +145,10 @@ module Unparser
           conditional_parentheses(parent_type == :mlhs) do
             delimited(children)
           end
+
+          if children.one? && !NO_COMMA.include?(children.first.type)
+            write(',')
+          end
         end
 
       end # MLHS

data/lib/unparser/emitter/begin.rb

@@ -25,6 +25,8 @@ module Unparser
 
         handle :begin
 
+        NON_EMPTY_PARENS = [:root, :dstr, :dyn_str_body].to_set.freeze
+
       private
 
         # Perform dispatch
@@ -34,7 +36,23 @@ module Unparser
         # @api private
         #
         def dispatch
-          emit_inner
+          if children.empty? && !NON_EMPTY_PARENS.include?(parent_type)
+            write('()')
+          else
+            conditional_parentheses(parent_type == :optarg) do
+              emit_inner
+            end
+          end
+        end
+
+        # Emit inner delimited by semicolons
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_inner_semi
+          delimited(children, ';')
         end
 
       end # Implicit
@@ -65,7 +83,10 @@ module Unparser
         # @api private
         #
         def emit_body
-          if NOINDENT.include?(body.type)
+          case
+          when body.nil?
+            nl
+          when NOINDENT.include?(body.type)
             emit_inner
           else
             indented { emit_inner }

data/lib/unparser/emitter/case.rb

@@ -60,7 +60,7 @@ module Unparser
       def emit_condition
         return unless condition
         write(WS)
-        visit(condition)
+        visit_terminated(condition)
       end
 
     end # Case

data/lib/unparser/emitter/class.rb

@@ -4,6 +4,7 @@ module Unparser
   class Emitter
     # Emitter for class nodes
     class Class < self
+      include LocalVariableRoot
 
       handle :class
 

data/lib/unparser/emitter/def.rb

@@ -4,6 +4,7 @@ module Unparser
   class Emitter
     # Emitter for def node
     class Def < self
+      include LocalVariableRoot
 
     private
 
@@ -88,10 +89,36 @@ module Unparser
         # @api private
         #
         def emit_name
-          visit(subject)
+          conditional_parentheses(!subject_without_parens?) do
+            visit(subject)
+          end
           write(T_DOT, name.to_s)
         end
 
+        # Test if subject needs parentheses
+        #
+        # @return [true]
+        #   if subject needs parentheses
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def subject_without_parens?
+          case subject.type
+          when :self
+            true
+          when :const
+            !subject.children.first
+          when :send
+            receiver, _selector, *arguments = *subject
+            !receiver && arguments.empty?
+          else
+            false
+          end
+        end
+
       end # Singleton
     end # Def
   end # Emitter

data/lib/unparser/emitter/defined.rb

@@ -19,7 +19,9 @@ module Unparser
       #
       def dispatch
         write(K_DEFINED)
-        visit_parentheses(subject)
+        parentheses do
+          visit_terminated(subject)
+        end
       end
 
     end # Defined

data/lib/unparser/emitter/flow_modifier.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module Unparser
+  class Emitter
+    # Emitter control flow modifiers
+    class FlowModifier < self
+
+      MAP = {
+        return: K_RETURN,
+        next:   K_NEXT,
+        break:  K_BREAK,
+      }
+
+      handle(*MAP.keys)
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        conditional_parentheses((parent_type == :or || parent_type == :and) && children.any?) do
+          write(MAP.fetch(node.type))
+          emit_arguments if children.any?
+        end
+      end
+
+      # Emit break or return arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_arguments
+        ws
+        head, *tail = children
+        emit_argument(head)
+        tail.each do |node|
+          write(DEFAULT_DELIMITER)
+          emit_argument(node)
+        end
+      end
+
+      PARENS = [:if, :case, :begin].to_set.freeze
+
+      # Emit argument
+      #
+      # @param [Parser::AST::Node] node
+      #
+      # @api private
+      #
+      def emit_argument(node)
+        conditional_parentheses(PARENS.include?(node.type)) do
+          visit(node)
+        end
+      end
+
+    end # Return
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/if.rb

@@ -18,6 +18,50 @@ module Unparser
       # @api private
       #
       def dispatch
+        if postcondition?
+          emit_postcondition
+        else
+          emit_normal
+        end
+      end
+
+      # Test for postcondition
+      #
+      # @return [true]
+      #   if node must be emitted in postconditin style
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def postcondition?
+        return false unless !!if_branch ^ !!else_branch
+
+        body = if_branch || else_branch
+
+        AST.first_assignment_in_body_and_used_in_condition?(local_variable_root, body, condition)
+      end
+
+      # Emit in postcondition style
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_postcondition
+        visit(if_branch || else_branch)
+        write(WS, keyword, WS)
+        emit_condition
+      end
+
+      # Emit in normal style
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_normal
         write(keyword, WS)
         emit_condition
         emit_if_branch