Merge pull request #15 from exercism/acronym

Acronym analyzer

Author: Karlo Soriano

lib/analyzer.rb

@@ -1,5 +1,6 @@
 EXERCISES = %w{
   two_fer
+  acronym
 }
 
 FILENAMES = {

lib/analyzers/acronym/analyze.rb

@@ -0,0 +1,33 @@
+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!
+      approve! if solution.uses_method_chain?
+      approve! if solution.uses_scan?
+      approve! if solution.uses_split?
+      approve!(:use_shorthand_block_syntax) if solution.uses_method_chain_with_block?
+
+      refer_to_mentor!
+    end
+
+    private
+
+    def approve!(msg = nil)
+      self.comments << MESSAGES[msg] if msg
+      self.status = :approve
+
+      raise FinishedFlowControlException
+    end
+
+    def refer_to_mentor!
+      self.status = :refer_to_mentor
+
+      raise FinishedFlowControlException
+    end
+  end
+end

lib/analyzers/acronym/representation.rb

@@ -0,0 +1,177 @@
+module Acronym
+  class Representation < SolutionRepresentation
+    def uses_method_chain?
+      matchers = [
+        {
+          method_name: :upcase,
+        },
+        {
+          method_name: :join,
+          chained?: true
+        },
+        {
+          method_name: :map,
+          arguments: [{ to_ast: s(:block_pass, s(:sym, :chr)) }],
+          chained?: true
+        },
+        {
+          method_name: :split,
+          chained?: true
+        },
+        {
+          method_name: :tr,
+          receiver: ArbitraryLvar.new,
+          chained?: true,
+          arguments: [{ to_ast: s(:str, "-") }, { to_ast: s(:str, " ") }]
+        }
+      ]
+
+      matches?(target_method.body, matchers)
+    end
+
+    def uses_method_chain_with_block?
+      arg = ArbitraryArg.new
+      matchers = [
+        {
+          method_name: :upcase,
+        },
+        {
+          method_name: :join,
+          chained?: true
+        },
+        {
+          type: :block,
+          method_name: :map,
+          chained?: true,
+          arguments: arg,
+        },
+        {
+          method_name: :map,
+        },
+        {
+          method_name: :split,
+          chained?: true
+        },
+        {
+          method_name: :tr,
+          receiver: ArbitraryLvar.new,
+          chained?: true,
+          arguments: [{ to_ast: s(:str, "-") }, { to_ast: s(:str, " ") }]
+        },
+        {
+          method_name: :chr,
+          receiver: arg.lvar
+        }
+      ]
+
+      matches?(target_method.body, matchers, [:send, :block])
+    end
+
+    def uses_scan?
+      matchers = [
+        {
+          method_name: :upcase,
+        },
+        {
+          method_name: :join,
+          chained?: true
+        },
+        {
+          method_name: :scan,
+          receiver: ArbitraryLvar.new,
+          chained?: true,
+          arguments: [{ type: :regexp }]
+        },
+      ]
+
+      matches?(target_method.body, matchers)
+    end
+
+    def uses_split?
+      matchers = [
+        {
+          method_name: :upcase,
+        },
+        {
+          method_name: :join,
+          chained?: true
+        },
+        {
+          method_name: :map,
+          chained?: true,
+          arguments: [{ to_ast: s(:block_pass, s(:sym, :chr)) }]
+        },
+        {
+          method_name: :split,
+          receiver: ArbitraryLvar.new,
+          arguments: [{ type: :regexp }]
+        }
+      ]
+
+      matches?(target_method.body, matchers)
+    end
+
+    private
+    memoize
+    def target_method
+      SA::Helpers.extract_module_method(target_module, "abbreviate")
+    end
+
+    memoize
+    def target_module
+      SA::Helpers.extract_module_or_class(root_node, "Acronym")
+    end
+
+    def matches?(body, matchers, types = [:send])
+      body.
+        each_node(*types).
+        with_index.
+        all? { |node, i| node_matches?(node, matchers[i]) }
+    end
+
+    def node_matches?(node, matcher)
+      matcher.
+        all? 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
+            expected_value == criteria_value
+          end
+        end
+    end
+  end
+end
+
+class ArbitraryLvar
+  def ==(other)
+    other.type == :lvar
+  end
+end
+
+class NamedLvar
+  attr_accessor :name
+
+  def ==(other)
+    other == Parser::AST::Node.new(:lvar, name)
+  end
+end
+
+class ArbitraryArg
+  def lvar
+    @lvar ||= NamedLvar.new
+  end
+
+  def ==(other)
+    if other.type == :args
+      lvar.name = other.first.node_parts
+    end
+
+    other.type == :args
+  end
+end

test/exercises/acronym_test.rb

@@ -0,0 +1,119 @@
+require "test_helper"
+require 'pry'
+
+class AcronymTest < Minitest::Test
+  def test_method_chaining_passes
+    source = %q{
+      class Acronym
+        def self.abbreviate(words)
+          words.tr('-', ' ').split.map(&:chr).join.upcase
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :approve, results[:status]
+    assert_equal [], results[:comments]
+  end
+
+  def test_lvar_name_not_tightly_coupled
+    source = %q{
+      class Acronym
+        def self.abbreviate(sentence)
+          sentence.tr('-', ' ').split.map(&:chr).join.upcase
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :approve, results[:status]
+    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_method_chaining_with_block_syntax_with_arbitrary_arg_passes
+    source = %q{
+      class Acronym
+        def self.abbreviate(words)
+          words.tr('-', ' ').split.map { |term| term.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
+        def self.abbreviate(words)
+          words.tr('-', ' ').split.map(&:chr).join.upcase
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :approve, results[:status]
+    assert_equal [], results[:comments]
+  end
+
+  def test_refers_to_mentor_with_method_not_matching
+    source = %q{
+      class Acronym
+        def self.abbreviate(words)
+          test.words.tr('-', ' ').split.map(&:chr).join.upcase
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :refer_to_mentor, results[:status]
+  end
+
+  def test_refers_to_mentor_with_random_method_body
+    source = %q{
+      class Acronym
+        def self.abbreviate(words)
+          anything_here.123.456.test_method
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :refer_to_mentor, results[:status]
+  end
+
+  def test_scan_with_any_regex_passes
+    source = %q{
+      class Acronym
+        def self.abbreviate(words)
+          words.scan(/any/).join.upcase
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :approve, results[:status]
+    assert_equal [], results[:comments]
+  end
+
+  def test_split_with_any_regex_passes
+    source = %q{
+      class Acronym
+        def self.abbreviate(words)
+          words.split(/[ -]/).map(&:chr).join.upcase
+        end
+      end
+    }
+    results = Acronym::Analyze.(source)
+    assert_equal :approve, results[:status]
+    assert_equal [], results[:comments]
+  end
+end