unparser 0.4.6 → 0.5.1

data/lib/unparser/emitter/for.rb

@@ -4,38 +4,24 @@ module Unparser
   class Emitter
     # Emitter for for nodes
     class For < self
-      include Terminated
-
       handle :for
 
       children :condition, :assignment, :body
 
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(K_FOR, WS)
+        write('for ')
         emit_condition
-        emit_body
+        emit_optional_body(body)
         k_end
       end
 
-      # Emit assignment
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_condition
-        visit_plain(condition)
-        write(WS, K_IN, WS)
+        visit(condition)
+        write(' in ')
         visit(assignment)
-        write(WS, K_DO)
+        write(' do')
       end
 
     end # For

data/lib/unparser/emitter/hash.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for Hash literals
+    class Hash < self
+      BAREWORD = /\A[A-Za-z_][A-Za-z_0-9]*[?!]?\z/.freeze
+
+      private_constant(*constants(false))
+
+      handle :hash
+
+      def emit_last_argument_hash
+        if children.empty?
+          write('{}')
+        else
+          emit_hash_body
+        end
+      end
+
+      def emit_heredoc_reminders
+        children.each(&method(:emit_heredoc_reminder_member))
+      end
+
+    private
+
+      def dispatch
+        if children.empty?
+          write('{}')
+        else
+          parentheses('{', '}') do
+            write(' ')
+            emit_hash_body
+            write(' ')
+          end
+        end
+      end
+
+      def emit_heredoc_reminder_member(node)
+        emitter(node.children.last).emit_heredoc_reminders
+      end
+
+      def emit_hash_body
+        delimited(children, &method(:emit_hash_member))
+      end
+
+      def emit_hash_member(node)
+        if n_kwsplat?(node)
+          visit(node)
+        else
+          emit_pair(node)
+        end
+      end
+
+      def emit_pair(pair)
+        key, value = *pair.children
+
+        if colon?(key)
+          write(key.children.first.to_s, ': ')
+        else
+          visit(key)
+          write(' => ')
+        end
+
+        visit(value)
+      end
+
+      def colon?(key)
+        n_sym?(key) && BAREWORD.match?(key.children.first)
+      end
+
+    end # Hash
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/hash_pattern.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for hash patterns
+    class HashPattern < self
+
+      handle :hash_pattern
+
+      def emit_const_pattern
+        parentheses do
+          emit_hash_body
+        end
+      end
+
+    private
+
+      def dispatch
+        parentheses('{', '}') do
+          emit_hash_body
+        end
+      end
+
+      def emit_hash_body
+        delimited(children, &method(:emit_member))
+      end
+
+      def emit_member(node)
+        case node.type
+        when :pair
+          emit_pair(node)
+        when :match_var
+          emit_match_var(node)
+        when :match_rest
+          writer_with(MatchRest, node).emit_hash_pattern
+        else
+          visit(node)
+        end
+      end
+
+      def emit_match_var(node)
+        write_symbol_body(node.children.first)
+        write(':')
+      end
+
+      def emit_pair(node)
+        key, value = node.children
+
+        if n_sym?(key)
+          write_symbol_body(key.children.first)
+        else
+          visit(s(:dstr, *key))
+        end
+
+        write(':')
+
+        ws
+
+        visit(value)
+      end
+
+      def write_symbol_body(symbol)
+        write(symbol.inspect[1..-1])
+      end
+    end # Pin
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/hookexe.rb

@@ -6,8 +6,8 @@ module Unparser
     class Hookexe < self
 
       MAP = {
-        preexe:  K_PREEXE,
-        postexe: K_POSTEXE
+        preexe:  'BEGIN',
+        postexe: 'END'
       }.freeze
 
       handle(*MAP.keys)
@@ -16,16 +16,10 @@ module Unparser
 
     private
 
-      # Perfrom dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
-        write(MAP.fetch(node.type), WS)
-        parentheses(*BRACKETS_CURLY) do
-          emit_body
+        write(MAP.fetch(node.type), ' ')
+        parentheses('{', '}') do
+          emit_body(body)
         end
       end
 

data/lib/unparser/emitter/if.rb

@@ -3,25 +3,13 @@
 module Unparser
   class Emitter
     # Emitter if nodes
-    #
-    # ignore :reek:RepeatedConditional
     class If < self
       handle :if
 
       children :condition, :if_branch, :else_branch
 
-      def terminated?
-        !postcondition?
-      end
-
     private
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def dispatch
         if postcondition?
           emit_postcondition
@@ -30,105 +18,53 @@ module Unparser
         end
       end
 
-      # Test for postcondition
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
       def postcondition?
         return false unless if_branch.nil? ^ else_branch.nil?
 
         body = if_branch || else_branch
 
-        local_variable_scope.first_assignment_in_body_and_used_in_condition?(body, condition)
+        local_variable_scope.first_assignment_in?(body, condition)
       end
 
-      # Emit in postcondition style
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_postcondition
-        visit_plain(if_branch || else_branch)
-        write(WS, keyword, WS)
+        visit(if_branch || else_branch)
+        write(' ', keyword, ' ')
         emit_condition
       end
 
-      # Emit in normal style
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_normal
-        write(keyword, WS)
+        write(keyword, ' ')
         emit_condition
         emit_if_branch
         emit_else_branch
         k_end
       end
 
-      # Test if AST can be emitted as unless
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      #
       def unless?
         !if_branch && else_branch
       end
 
-      # Return keyword
-      #
-      # @return [String]
-      #
-      # @api private
-      #
       def keyword
-        unless? ? K_UNLESS : K_IF
+        unless? ? 'unless' : 'if'
       end
 
-      # Emit condition
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_condition
-        if condition.type.equal?(:match_current_line)
-          visit_plain(condition)
-        else
-          visit(condition)
-        end
+        visit(condition)
       end
 
-      # Emit if branch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_if_branch
         if if_branch
-          visit_indented(if_branch)
+          emit_body(if_branch)
         end
 
         nl if !if_branch && !else_branch
       end
 
-      # Emit else branch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
       def emit_else_branch
         return unless else_branch
 
-        write(K_ELSE) unless unless?
-        visit_indented(else_branch)
+        write('else') unless unless?
+        emit_body(else_branch)
       end
 
     end # If

data/lib/unparser/emitter/in_match.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class InMatch < self
+
+      handle :in_match
+
+      children :target, :pattern
+
+    private
+
+      def dispatch
+        visit(target)
+        write(' in ')
+        visit(pattern)
+      end
+    end # InMatch
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/in_pattern.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Unparser
+  class Emitter
+    # Emitter for in pattern nodes
+    class InPattern < self
+
+      handle :in_pattern
+
+      children :target, :unless_guard, :branch, :else_branch
+
+    private
+
+      def dispatch
+        write('in')
+
+        ws
+
+        visit(target)
+
+        if unless_guard
+          ws
+          visit(unless_guard)
+        end
+
+        if branch
+          ws
+          write('then')
+          emit_body(branch)
+        end
+      end
+    end # InPattern
+  end # Emitter
+end # Unparser

data/lib/unparser/emitter/index.rb

@@ -3,61 +3,29 @@
 module Unparser
   class Emitter
     # Emitter for send to index references
-    #
-    # ignore :reek:RepeatedConditional
     class Index < self
 
-      # Perform dispatch
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
+    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)
+          parentheses('[', ']') do
+            delimited(indices)
           end
         end
       end # Reference
@@ -70,65 +38,30 @@ module Unparser
         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
+        private_constant(*constants(false))
 
-        # 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
+        def emit_heredoc_reminders
+          emitter(children.last).emit_heredoc_reminders
         end
 
-        # The indices
-        #
-        # @return [Array<Parser::AST::Node>]
-        #
-        def indices
-          if emit_value?
-            children[VALUE_RANGE]
-          else
-            children.drop(1)
-          end
+        def dispatch
+          emit_receiver
+          emit_operation(children[VALUE_RANGE])
+          write(' = ')
+          visit(children.last)
         end
 
-        # Test if value should be emitted
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        #
-        def emit_value?
-          !mlhs? && !no_value_parent?
+        def emit_mlhs
+          emit_receiver
+          emit_operation(children.drop(1))
         end
 
-        # Test for no value parent
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        #
-        def no_value_parent?
-          NO_VALUE_PARENT.include?(parent_type)
+      private
+
+        def emit_operation(indices)
+          parentheses('[', ']') do
+            delimited(indices)
+          end
         end
       end # Assign
     end # Index