unparser 0.3.0 → 0.4.0

data/lib/unparser/cli/differ.rb

@@ -97,7 +97,7 @@ module Unparser
       # @api private
       #
       def diff
-        output = ''
+        output = +''
 
         collapsed_hunks.each do |hunk|
           output << hunk.diff(:unified) << "\n"

data/lib/unparser/cli/source.rb

@@ -182,7 +182,7 @@ module Unparser
       # @api private
       #
       def generated_ast
-        generated.success? && Preprocessor.run(parse(generated.source))
+        generated.success? && Preprocessor.run(Unparser.parse(generated.source))
       rescue Parser::SyntaxError
         nil
       end
@@ -195,25 +195,12 @@ module Unparser
       # @api private
       #
       def original_ast
-        Preprocessor.run(parse(original_source))
+        Preprocessor.run(Unparser.parse(original_source))
       rescue Parser::SyntaxError
         nil
       end
       memoize :original_ast
 
-      # Parse source with current ruby
-      #
-      # @param [String] source
-      #
-      # @return [Parser::AST::Node]
-      #
-      # @api private
-      #
-      # ignore :reek:UtilityFunction
-      def parse(source)
-        Parser::CurrentRuby.parse(source)
-      end
-
       # CLI source from string
       class String < self
         include Concord.new(:original_source)

data/lib/unparser/constants.rb

@@ -22,6 +22,10 @@ module Unparser
     end
     private_class_method :symbol_set
 
+    BRACKETS_CURLY  = IceNine.deep_freeze(%w[{ }])
+    BRACKETS_ROUND  = IceNine.deep_freeze(%w[( )])
+    BRACKETS_SQUARE = IceNine.deep_freeze(%w([ ]))
+
     # All unary operators of the ruby language
     UNARY_OPERATORS = symbol_set %w[
       ! ~ -@ +@
@@ -105,8 +109,6 @@ module Unparser
 
     DEFAULT_DELIMITER = ', '.freeze
 
-    CURLY_BRACKETS = IceNine.deep_freeze(%w[{ }])
-
     KEYWORDS = constants.each_with_object([]) do |name, keywords|
       value = const_get(name).freeze
       next unless name.to_s.start_with?('K_')

data/lib/unparser/emitter.rb

@@ -17,10 +17,6 @@ module Unparser
 
     NOINDENT = %i[rescue ensure].to_set.freeze
 
-    DEFAULT_DELIMITER = ', '.freeze
-
-    CURLY_BRACKETS = IceNine.deep_freeze(%w[{ }])
-
     module Unterminated
       def terminated?
         false
@@ -111,16 +107,6 @@ module Unparser
     end
     memoize :write_to_buffer
 
-    # Emit node
-    #
-    # @return [self]
-    #
-    # @api private
-    #
-    def self.emit(*arguments)
-      new(*arguments).write_to_buffer
-    end
-
     # Return emitter
     #
     # @return [Emitter]

data/lib/unparser/emitter/argument.rb

@@ -30,6 +30,7 @@ module Unparser
       handle :args
 
       SHADOWARGS = ->(node) { node.type.equal?(:shadowarg) }.freeze
+      ARG        = ->(node) { node.type.equal?(:arg) }.freeze
 
     private
 
@@ -41,12 +42,35 @@ module Unparser
       #
       def dispatch
         delimited(normal_arguments)
+
+        write(', ') if procarg_disambiguator?
+
         return if shadowargs.empty?
 
         write('; ')
         delimited(shadowargs)
       end
 
+      # Test for procarg_disambiguator
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def procarg_disambiguator?
+        regular_block? && normal_arguments.all?(&ARG) && normal_arguments.one?
+      end
+
+      # Test for regular block
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def regular_block?
+        parent_type.equal?(:block) && !parent.node.children.first.type.equal?(:lambda)
+      end
+
       # Return normal arguments
       #
       # @return [Enumerable<Parser::AST::Node>]
@@ -56,6 +80,7 @@ module Unparser
       def normal_arguments
         children.reject(&SHADOWARGS)
       end
+      memoize :normal_arguments
 
       # Return shadow args
       #
@@ -209,6 +234,43 @@ module Unparser
 
     end # Argument
 
+    # Progarg emitter
+    class Procarg < self
+      include Terminated
+
+      handle :procarg0
+
+      children :first_argument
+
+    private
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        if first_argument.instance_of?(Symbol)
+          write(first_argument.to_s)
+        else
+          emit_multiple_children
+        end
+      end
+
+      # Emit multiple children
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_multiple_children
+        parentheses do
+          delimited(children)
+        end
+      end
+    end
+
     # Block pass node emitter
     class BlockPass < self
       include Terminated

data/lib/unparser/emitter/assignment.rb

@@ -29,7 +29,7 @@ module Unparser
         # @api private
         #
         def terminated?
-          right_node.nil?
+          right.nil?
         end
 
       private
@@ -41,7 +41,6 @@ module Unparser
         # @api private
         #
         def emit_right
-          right = right_node
           return unless right
 
           write(WS, T_ASN, WS)
@@ -55,7 +54,7 @@ module Unparser
 
           handle :lvasgn, :ivasgn, :cvasgn, :gvasgn
 
-          children :name, :right_node
+          children :name, :right
 
         private
 
@@ -76,7 +75,7 @@ module Unparser
 
           handle :casgn
 
-          children :base, :name, :right_node
+          children :base, :name, :right
 
         private
 
@@ -103,8 +102,6 @@ module Unparser
 
         handle :masgn
 
-        PARENS = IceNine.deep_freeze(%w([ ]))
-
       private
 
         # Emit left
@@ -125,16 +122,7 @@ module Unparser
         #
         def emit_right
           write(WS, T_ASN, WS)
-          right = children.last
-          case right.type
-          when :array
-            children = right.children
-            parentheses(*PARENS) do
-              delimited(children)
-            end
-          else
-            visit(right)
-          end
+          visit(children.last)
         end
 
       end # Multiple

data/lib/unparser/emitter/block.rb

@@ -4,12 +4,14 @@ module Unparser
   class Emitter
 
     # Block emitter
+    #
+    # ignore :reek:RepeatedConditional
     class Block < self
       include Terminated
 
       handle :block
 
-      children :send, :arguments, :body
+      children :target, :arguments, :body
 
     private
 
@@ -20,14 +22,37 @@ module Unparser
       # @api private
       #
       def dispatch
-        visit(send)
+        emit_target
         write(WS, K_DO)
-        comments.consume(node, :begin)
-        emit_block_arguments
+        emit_block_arguments unless stabby_lambda?
         emit_body
         k_end
       end
 
+      # Emit target
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_target
+        visit(target)
+
+        if stabby_lambda?
+          parentheses { visit(arguments) }
+        end
+      end
+
+      # Test if we are emitting a stabby lambda
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def stabby_lambda?
+        target.type.equal?(:lambda)
+      end
+
       # Emit arguments
       #
       # @return [undefined]

data/lib/unparser/emitter/hookexe.rb

@@ -24,7 +24,7 @@ module Unparser
       #
       def dispatch
         write(MAP.fetch(node.type), WS)
-        parentheses(*CURLY_BRACKETS) do
+        parentheses(*BRACKETS_CURLY) do
           emit_body
         end
       end

data/lib/unparser/emitter/index.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for send to index references
+    #
+    # ignore :reek:RepeatedConditional
+    class Index < self
+
+      # Perform dispatch
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def dispatch
+        emit_receiver
+        emit_operation
+      end
+
+    private
+
+      # Emit receiver
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_receiver
+        visit(first_child)
+      end
+
+      # Test for mlhs
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def mlhs?
+        parent_type.equal?(:mlhs)
+      end
+
+      class Reference < self
+        include Terminated
+
+        define_group(:indices, 1..-1)
+
+        handle :index
+
+      private
+
+        # Emit arguments
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_operation
+          parentheses(*BRACKETS_SQUARE) do
+            delimited_plain(indices)
+          end
+        end
+      end # Reference
+
+      # Emitter for assign to index nodes
+      class Assign < self
+
+        handle :indexasgn
+
+        VALUE_RANGE     = (1..-2).freeze
+        NO_VALUE_PARENT = IceNine.deep_freeze(%i[and_asgn op_asgn or_asgn].to_set)
+
+        # Test if assign will be emitted terminated
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        #
+        def terminated?
+          !emit_value?
+        end
+
+      private
+
+        # Emit arguments
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_operation
+          parentheses(*BRACKETS_SQUARE) do
+            delimited_plain(indices)
+          end
+
+          if emit_value?
+            write(WS, T_ASN, WS)
+            visit(children.last)
+          end
+        end
+
+        # The indices
+        #
+        # @return [Array<Parser::AST::Node>]
+        #
+        def indices
+          if emit_value?
+            children[VALUE_RANGE]
+          else
+            children.drop(1)
+          end
+        end
+
+        # Test if value should be emitted
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        #
+        def emit_value?
+          !mlhs? && !no_value_parent?
+        end
+
+        # Test for no value parent
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        #
+        def no_value_parent?
+          NO_VALUE_PARENT.include?(parent_type)
+        end
+      end # Assign
+    end # Index
+  end # Emitter
+end # Unparser