Support alternations in matches

lib/natalie/compiler/transformers/match_required_node.rb

@@ -102,12 +102,22 @@ def transform_array_pattern_node(node, value)
 
         def transform_eqeqeq_check(node, value)
           # Transform `expr => var` into `->(res, var) { res === var }.call(expr, var)`
+          alternations = []
+          alternation_handler = lambda do |n|
+            if n.is_a?(Prism::AlternationPatternNode)
+              alternation_handler.call(n.left)
+              alternation_handler.call(n.right)
+            else
+              alternations << n.location.slice
+            end
+          end
+          alternation_handler.call(node)
           <<~RUBY
             lambda do |result, expect|
-              unless expect === result
-                raise ::NoMatchingPatternError, "\#{result}: \#{expect} === \#{result} does not return true"
+              if expect.none? { |e| e === result }
+                raise ::NoMatchingPatternError, "\#{result}: \#{expect.last} === \#{result} does not return true"
               end
-            end.call(#{value.location.slice}, #{node.location.slice})
+            end.call(#{value.location.slice}, [#{alternations.join(', ')}])
           RUBY
         end
 

test/natalie/pattern_matching_test.rb

@@ -357,6 +357,20 @@ def self.one = 1
       [1, 2] => *, ^a
     }.should raise_error(NoMatchingPatternError, '[1, 2]: 1 === 2 does not return true')
   end
+
+  it 'can handle alternation' do
+    1 => String | Integer
+  end
+
+  it 'can handle more than 2 alternations' do
+    1 => String | Symbol | Integer
+  end
+
+  it 'can fail with missing alternation' do
+    -> {
+      1 => String | Symbol
+    }.should raise_error(NoMatchingPatternError, '1: Symbol === 1 does not return true')
+  end
 end
 
 describe 'NoMatchingPatternError' do