Approve with comment when using method chaining with a longform block syntax

Author: kntsoriano

lib/analyzers/acronym/analyze.rb

@@ -2,12 +2,27 @@ module Acronym
   class Analyze < ExerciseAnalyzer
     include Mandate
 
+    MESSAGES = {
+      use_shorthand_block_syntax: "ruby.acronym.block_syntax.shorthand", # "Use ruby's short hand block syntax to be more concise"
+    }
+
     def analyze!
-      if solution.uses_method_chain? || solution.uses_scan? || solution.uses_split?
-        self.status = :approve
+      approve! if approve_without_comment?
+
+      approve!(:use_shorthand_block_syntax) if solution.uses_method_chain_with_block?
+    end
+
+    private
+
+    def approve_without_comment?
+      solution.uses_method_chain? || solution.uses_scan? || solution.uses_split?
+    end
+
+    def approve!(msg = nil)
+      self.comments << MESSAGES[msg] if msg
+      self.status = :approve
 
-        raise FinishedFlowControlException
-      end
+      raise FinishedFlowControlException
     end
   end
 end

lib/analyzers/acronym/representation.rb

@@ -29,6 +29,40 @@ def uses_method_chain?
       matches?(target_method.body, matchers)
     end
 
+    def uses_method_chain_with_block?
+      matchers = [
+        {
+          method_name: :upcase,
+        },
+        {
+          method_name: :join,
+          chained?: true
+        },
+        {
+          type: :block,
+          method_name: :map,
+          chained?: true,
+          arguments: s(:args, s(:arg, :word)),
+          body: s(:send, s(:lvar, :word), :chr)
+        },
+        {
+          method_name: :map,
+        },
+        {
+          method_name: :split,
+          chained?: true
+        },
+        {
+          method_name: :tr,
+          receiver: s(:lvar, :words),
+          chained?: true,
+          arguments: [{ to_ast: s(:str, "-") }, { to_ast: s(:str, " ") }]
+        }
+      ]
+
+      matches?(target_method.body, matchers, [:send, :block])
+    end
+
     def uses_scan?
       matchers = [
         {
@@ -84,9 +118,9 @@ def target_module
       SA::Helpers.extract_module_or_class(root_node, "Acronym")
     end
 
-    def matches?(body, matchers)
+    def matches?(body, matchers, types = [:send])
       body.
-        each_node(:send).
+        each_node(*types).
         with_index.
         all? { |node, i| node_matches?(node, matchers[i]) }
     end

test/exercises/acronym_test.rb

@@ -15,6 +15,19 @@ def self.abbreviate(words)
     assert_equal [], results[:comments]
   end
 
+  def test_method_chaining_with_block_syntax_passes_with_comment
+    source = %q{
+      class Acronym
+        def self.abbreviate(words)
+          words.tr('-', ' ').split.map { |word| word.chr }.join.upcase
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :approve, results[:status]
+    assert_equal ["ruby.acronym.block_syntax.shorthand"], results[:comments]
+  end
+
   def test_module_method_passes
     source = %q{
       module Acronym