Merge pull request #395 from viralpraxis/fix-array-pattern-unparsing

Fix array pattern unparsing

Author: mbj

lib/unparser.rb

@@ -295,6 +295,7 @@ def self.buffer(source, identification = '(string)')
 require 'unparser/emitter/match_pattern'
 require 'unparser/emitter/match_pattern_p'
 require 'unparser/writer'
+require 'unparser/writer/array'
 require 'unparser/writer/binary'
 require 'unparser/writer/dynamic_string'
 require 'unparser/writer/regexp'
@@ -308,6 +309,7 @@ def self.buffer(source, identification = '(string)')
 require 'unparser/node_details'
 require 'unparser/node_details/send'
 require 'unparser/cli'
+require 'unparser/util'
 
 require 'unparser/validation'
 # make it easy for zombie

lib/unparser/emitter/in_pattern.rb

@@ -16,7 +16,7 @@ def dispatch
 
         ws
 
-        visit(target)
+        dispatch_target(target)
 
         if unless_guard
           ws
@@ -31,6 +31,14 @@ def dispatch
           nl
         end
       end
+
+      def dispatch_target(target)
+        if n_array?(target)
+          writer_with(Writer::Array, node: target).emit_compact
+        else
+          visit(target)
+        end
+      end
     end # InPattern
   end # Emitter
 end # Unparser

lib/unparser/emitter/match_pattern.rb

@@ -14,7 +14,12 @@ class MatchPattern < self
       def dispatch
         visit(target)
         write(' => ')
-        visit(pattern)
+
+        if n_array?(pattern)
+          writer_with(Writer::Array, node: pattern).emit_compact
+        else
+          visit(pattern)
+        end
       end
     end # MatchPattern
   end # Emitter

lib/unparser/emitter/match_pattern_p.rb

@@ -13,7 +13,12 @@ class MatchPatternP < self
       def dispatch
         visit(target)
         write(' in ')
-        visit(pattern)
+
+        if n_array?(pattern)
+          writer_with(Writer::Array, node: pattern).emit_compact
+        else
+          visit(pattern)
+        end
       end
     end # MatchPatternP
   end # Emitter

lib/unparser/util.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Unparser
+  # Original code before vendoring and reduction from: https://github.com/mbj/mutant/blob/main/lib/mutant/util.rb
+  module Util
+    # Error raised by `Util.one` if size is not exactly one
+    SizeError = Class.new(IndexError)
+
+    # Return only element in array if it contains exactly one member
+    #
+    # @param array [Array]
+    #
+    # @return [Object] first entry
+    def self.one(array)
+      case array
+      in [value]
+        value
+      else
+        fail SizeError, "expected size to be exactly 1 but size was #{array.size}"
+      end
+    end
+  end
+end

lib/unparser/writer/array.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Unparser
+  module Writer
+    class Array
+      include Writer, Adamantium
+
+      MAP = {
+        dsym: '%I',
+        sym:  '%i',
+        dstr: '%W',
+        str:  '%w'
+      }.freeze
+      private_constant(*constants(false))
+
+      def emit_compact # rubocop:disable Metrics/AbcSize
+        children_generic_type = array_elements_generic_type
+
+        write(MAP.fetch(children_generic_type))
+
+        parentheses('[', ']') do
+          delimited(children, ' ') do |child|
+            if n_sym?(child) || n_str?(child)
+              write(Util.one(child.children).to_s)
+            else
+              write('#{')
+              emitter(unwrap_single_begin(Util.one(child.children))).write_to_buffer
+              write('}')
+            end
+          end
+        end
+      end
+
+      private
+
+      def array_elements_generic_type
+        children_types = children.to_set(&:type)
+
+        if children_types == Set[:sym, :dsym]
+          :dsym
+        elsif children_types == Set[:str, :dstr]
+          :dstr
+        elsif children_types == Set[]
+          :sym
+        else
+          Util.one(children_types.to_a)
+        end
+      end
+    end # Array
+  end # Writer
+end # Unparser

spec/unit/unparser/util_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Unparser::Util, '.one' do
+  let(:item) { instance_double(Object) }
+
+  def apply
+    described_class.one(array)
+  end
+
+  context 'when array has exactly one element' do
+    context 'and that element is nil' do
+      let(:array) { [nil] }
+
+      it 'returns nil' do
+        expect(apply).to be(nil)
+      end
+    end
+
+    context 'and that element is false' do
+      let(:array) { [false] }
+
+      it 'returns false' do
+        expect(apply).to be(false)
+      end
+    end
+
+    context 'and that element is a regular object' do
+      let(:array) { [item] }
+
+      it 'returns first element' do
+        expect(apply).to be(item)
+      end
+    end
+  end
+
+  context 'when array is empty' do
+    let(:array) { [] }
+
+    it 'raises expected error' do
+      expect { apply }
+        .to raise_error(described_class::SizeError)
+        .with_message('expected size to be exactly 1 but size was 0')
+    end
+  end
+
+  context 'when array has more than one element' do
+    let(:array) { [1, 2] }
+
+    it 'raises expected error' do
+      expect { apply }
+        .to raise_error(described_class::SizeError)
+        .with_message('expected size to be exactly 1 but size was 2')
+    end
+  end
+end

test/corpus/literal/pattern.rb

@@ -43,3 +43,40 @@
 1 => [*]
 1 in [*, 42, *]
 1 in [*, a, *foo]
+a => %i[a b]
+a => %w[a b]
+a => ["a", "b"]
+a => [:a, :b]
+a => [:a, "b"]
+a => [true, false, nil]
+a => {a: 1, b: 2}
+a in %i[a b]
+a in %w[a b]
+a in ["a", "b"]
+a in [:a, :b]
+a in [:a, "b"]
+a in [true, false, nil]
+a in {a: 1, b: 2}
+case foo
+in %i[a b]
+end
+case foo
+in %w[a b]
+end
+case foo
+in [:a, "b"]
+end
+case foo
+in [1, 2]
+end
+case foo
+in [true, false, nil]
+end
+a => %I[a b #{foo(1)}]
+a => %W[a b #{foo(1)}]
+case a
+in %I[#{1 + 1}]
+end
+case foo
+in %i[a b c $FILE]
+end

test/corpus/semantic/pattern.rb

@@ -0,0 +1,27 @@
+case foo
+in %s[a b]
+end
+case foo
+in %r[foo]
+end
+case foo
+in %r[/foo.+bar/]
+end
+case foo
+in %r:/foo.+bar/:
+end
+case foo
+in %x(rm -rf /)
+end
+case foo
+in %i[]
+end
+case foo
+in %w[]
+end
+case foo
+in %q[a b c #{foo}]
+end
+case foo
+in %q[a b c $FILE]
+end