Refactor heuristics

test/test_heuristics.rb

@@ -11,6 +11,11 @@ class TestHeuristcs < Test::Unit::TestCase
     File.read(File.join(samples_path, name))
   end
 
+  def file_blob(name)
+    path = File.exist?(name) ? name : File.join(samples_path, name)
+    FileBlob.new(path)
+  end
+
   def all_fixtures(language_name, file="*")
     Dir.glob("#{samples_path}/#{language_name}/#{file}")
   end
@@ -37,45 +42,41 @@ class TestHeuristcs < Test::Unit::TestCase
   end
 
   # Candidate languages = ["Perl", "Prolog"]
-  def test_pl_prolog_by_heuristics
-    results = Heuristics.disambiguate_pl(fixture("Prolog/turing.pl"))
-    assert_equal Language["Prolog"], results.first
-  end
-
-  # Candidate languages = ["Perl", "Prolog"]
-  def test_pl_perl_by_heuristics
-    results = Heuristics.disambiguate_pl(fixture("Perl/perl-test.t"))
-    assert_equal Language["Perl"], results.first
+  def test_pl_prolog_perl_by_heuristics
+    assert_heuristics({
+      "Prolog" => "Prolog/turing.pl",
+      "Perl" => "Perl/perl-test.t",
+    })
   end
 
   # Candidate languages = ["ECL", "Prolog"]
   def test_ecl_prolog_by_heuristics
-    results = Heuristics.disambiguate_ecl(fixture("Prolog/or-constraint.ecl"))
-    assert_equal Language["Prolog"], results.first
+    results = Heuristics.call(file_blob("Prolog/or-constraint.ecl"), [Language["ECL"], Language["Prolog"]])
+    assert_equal [Language["Prolog"]], results
   end
 
   # Candidate languages = ["ECL", "Prolog"]
-  def test_ecl_ecl_by_heuristics
-    results = Heuristics.disambiguate_ecl(fixture("ECL/sample.ecl"))
-    assert_equal Language["ECL"], results.first
+  def test_ecl_prolog_by_heuristics
+    assert_heuristics({
+      "ECL" => "ECL/sample.ecl",
+      "Prolog" => "Prolog/or-constraint.ecl"
+    })
   end
 
   # Candidate languages = ["IDL", "Prolog"]
-  def test_pro_prolog_by_heuristics
-    results = Heuristics.disambiguate_pro(fixture("Prolog/logic-problem.pro"))
-    assert_equal Language["Prolog"], results.first
-  end
-
-  # Candidate languages = ["IDL", "Prolog"]
-  def test_pro_idl_by_heuristics
-    results = Heuristics.disambiguate_pro(fixture("IDL/mg_acosh.pro"))
-    assert_equal Language["IDL"], results.first
+  def test_pro_prolog_idl_by_heuristics
+    assert_heuristics({
+      "Prolog" => "Prolog/logic-problem.pro",
+      "IDL" => "IDL/mg_acosh.pro"
+    })
   end
 
   # Candidate languages = ["AGS Script", "AsciiDoc"]
   def test_asc_asciidoc_by_heuristics
-    results = Heuristics.disambiguate_asc(fixture("AsciiDoc/list.asc"))
-    assert_equal Language["AsciiDoc"], results.first
+    assert_heuristics({
+      "AsciiDoc" => "AsciiDoc/list.asc",
+      "AGS Script" => nil
+    })
   end
 
   # Candidate languages = ["TypeScript", "XML"]
@@ -91,49 +92,50 @@ class TestHeuristcs < Test::Unit::TestCase
   end
 
   def test_cl_by_heuristics
-    languages = ["Common Lisp", "OpenCL"]
-    languages.each do |language|
-      all_fixtures(language).each do |fixture|
-        results = Heuristics.disambiguate_cl(fixture("#{language}/#{File.basename(fixture)}"))
-        assert_equal Language[language], results.first
-      end
-    end
+    assert_heuristics({
+      "Common Lisp" => all_fixtures("Common Lisp"),
+      "OpenCL" => all_fixtures("OpenCL")
+    })
   end
 
   def test_f_by_heuristics
-    languages = ["FORTRAN", "Forth"]
-    languages.each do |language|
-      all_fixtures(language).each do |fixture|
-        results = Heuristics.disambiguate_f(fixture("#{language}/#{File.basename(fixture)}"))
-        assert_equal Language[language], results.first
-      end
-    end
+    assert_heuristics({
+      "FORTRAN" => all_fixtures("FORTRAN"),
+      "Forth" => all_fixtures("Forth")
+    })
   end
 
   # Candidate languages = ["Hack", "PHP"]
   def test_hack_by_heuristics
-    results = Heuristics.disambiguate_hack(fixture("Hack/funs.php"))
-    assert_equal Language["Hack"], results.first
+    assert_heuristics({
+      "Hack" => "Hack/funs.php",
+      "PHP" => "PHP/Model.php"
+    })
   end
 
   # Candidate languages = ["Scala", "SuperCollider"]
-  def test_sc_supercollider_by_heuristics
-    results = Heuristics.disambiguate_sc(fixture("SuperCollider/WarpPreset.sc"))
-    assert_equal Language["SuperCollider"], results.first
-  end
-
-  # Candidate languages = ["Scala", "SuperCollider"]
-  def test_sc_scala_by_heuristics
-    results = Heuristics.disambiguate_sc(fixture("Scala/node11.sc"))
-    assert_equal Language["Scala"], results.first
+  def test_sc_supercollider_scala_by_heuristics
+    assert_heuristics({
+      "SuperCollider" => "SuperCollider/WarpPreset.sc",
+      "Scala" => "Scala/node11.sc"
+    })
   end
 
   def test_fs_by_heuristics
-    languages = ["F#", "Forth", "GLSL"]
-    languages.each do |language|
-      all_fixtures(language).each do |fixture|
-        results = Heuristics.disambiguate_fs(fixture("#{language}/#{File.basename(fixture)}"))
-        assert_equal Language[language], results.first
+    assert_heuristics({
+      "F#" => all_fixtures("F#"),
+      "Forth" => all_fixtures("Forth"),
+      "GLSL" => all_fixtures("GLSL")
+    })
+  end
+
+  def assert_heuristics(hash)
+    candidates = hash.keys.map { |l| Language[l] }
+
+    hash.each do |language, blobs|
+      Array(blobs).each do |blob|
+        result = Heuristics.call(file_blob(blob), candidates)
+        assert_equal [Language[language]], result
       end
     end
   end