Approve acronym when using scan without any regexp

Author: kntsoriano

lib/analyzers/acronym/representation.rb

@@ -1,6 +1,5 @@
 module Acronym
   class Representation < SolutionRepresentation
-
     def uses_method_chain?
       target_method.body == s(:send,
                               s(:send,
@@ -17,15 +16,27 @@ def uses_method_chain?
     end
 
     def uses_scan?
-      target_method.body == s(:send,
-                              s(:send,
-                                s(:send,
-                                  s(:lvar, :words),
-                                  :scan,
-                                  s(:regexp, s(:str, "\\b[[:alpha:]]"), s(:regopt))
-                                ),
-                                :join),
-                              :upcase)
+      matchers = [
+        {
+          method_name: :upcase,
+        },
+        {
+          method_name: :join,
+          chained?: true
+        },
+        {
+          method_name: :scan,
+          receiver: s(:lvar, :words),
+          chained?: true,
+          arguments: [{ type: :regexp }]
+        },
+      ]
+
+      target_method.
+        body.
+        each_node(:send).
+        with_index.
+        all? { |node, i| node_matches?(node, matchers[i]) }
     end
 
     private
@@ -38,5 +49,23 @@ def target_method
     def target_module
       SA::Helpers.extract_module_or_class(root_node, "Acronym")
     end
+
+    def node_matches?(node, matcher)
+      matcher.
+        map do |criteria|
+          key, expected_value = *criteria
+          criteria_value = node.send(key)
+
+          case criteria_value
+          when Array
+            criteria_value.each_with_index.all? do |n, i|
+              node_matches?(n, expected_value[i])
+            end
+          else
+            criteria_value == expected_value
+          end
+        end.
+        all?
+    end
   end
 end

test/exercises/acronym_test.rb

@@ -15,11 +15,11 @@ def self.abbreviate(words)
     assert_equal [], results[:comments]
   end
 
-  def test_scan_passes
+  def test_scan_with_any_regex_passes
     source = %q{
       class Acronym
         def self.abbreviate(words)
-          words.scan(/\b[[:alpha:]]/).join.upcase
+          words.scan(/any/).join.upcase
         end
       end
     }