Merge master

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
@@ -18,16 +23,17 @@ class TestHeuristcs < Test::Unit::TestCase
   # Candidate languages = ["C++", "Objective-C"]
   def test_obj_c_by_heuristics
     # Only calling out '.h' filenames as these are the ones causing issues
-    all_fixtures("Objective-C", "*.h").each do |fixture|
-      results = Heuristics.disambiguate_c(fixture("Objective-C/#{File.basename(fixture)}"))
-      assert_equal Language["Objective-C"], results.first
-    end
+    assert_heuristics({
+      "Objective-C" => all_fixtures("Objective-C", "*.h"),
+      "C++" => ["C++/render_adapter.cpp", "C++/ThreadedQueue.h"],
+      "C" => nil
+    })
   end
 
-  # Candidate languages = ["C++", "Objective-C"]
-  def test_cpp_by_heuristics
-    results = Heuristics.disambiguate_c(fixture("C++/render_adapter.cpp"))
-    assert_equal Language["C++"], results.first
+  def test_c_by_heuristics
+    languages = [Language["C++"], Language["Objective-C"], Language["C"]]
+    results = Heuristics.call(file_blob("C/ArrowLeft.h"), languages)
+    assert_equal [], results
   end
 
   def test_detect_still_works_if_nothing_matches
@@ -37,103 +43,82 @@ 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
-  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
+    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
-  end
-
-  # Candidate languages = ["TypeScript", "XML"]
-  def test_ts_typescript_by_heuristics
-    results = Heuristics.disambiguate_ts(fixture("TypeScript/classes.ts"))
-    assert_equal Language["TypeScript"], results.first
-  end
-
-  # Candidate languages = ["TypeScript", "XML"]
-  def test_ts_xml_by_heuristics
-    results = Heuristics.disambiguate_ts(fixture("XML/pt_BR.xml"))
-    assert_equal Language["XML"], results.first
+    assert_heuristics({
+      "AsciiDoc" => "AsciiDoc/list.asc",
+      "AGS Script" => nil
+    })
   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

test/test_language.rb

@@ -223,34 +223,21 @@ class TestLanguage < Test::Unit::TestCase
     assert_equal [Language['Chapel']], Language.find_by_filename('examples/hello.chpl')
   end
 
-  def test_find_by_shebang
-    assert_equal 'ruby', Linguist.interpreter_from_shebang("#!/usr/bin/ruby\n# baz")
-    { []         => ["",
-                     "foo",
-                     "#bar",
-                     "#baz",
-                     "///",
-                     "\n\n\n\n\n",
-                     " #!/usr/sbin/ruby",
-                     "\n#!/usr/sbin/ruby"],
-      ['Ruby']   => ["#!/usr/bin/env ruby\n# baz",
-                     "#!/usr/sbin/ruby\n# bar",
-                     "#!/usr/bin/ruby\n# foo",
-                     "#!/usr/sbin/ruby",
-                     "#!/usr/sbin/ruby foo bar baz\n"],
-      ['R']      => ["#!/usr/bin/env Rscript\n# example R script\n#\n"],
-      ['Shell']  => ["#!/usr/bin/bash\n", "#!/bin/sh"],
-      ['Python'] => ["#!/bin/python\n# foo\n# bar\n# baz",
-                     "#!/usr/bin/python2.7\n\n\n\n",
-                     "#!/usr/bin/python3\n\n\n\n"],
-      ["Common Lisp"] => ["#!/usr/bin/sbcl --script\n\n"]
-    }.each do |languages, bodies|
-      bodies.each do |body|
-        assert_equal([body, languages.map{|l| Language[l]}],
-                     [body, Language.find_by_shebang(body)])
-
-      end
+  def test_find_by_interpreter
+    {
+      "ruby" => "Ruby",
+      "Rscript" => "R",
+      "sh" => "Shell",
+      "bash" => "Shell",
+      "python" => "Python",
+      "python2" => "Python",
+      "python3" => "Python",
+      "sbcl" => "Common Lisp"
+    }.each do |interpreter, language|
+      assert_equal [Language[language]], Language.find_by_interpreter(interpreter)
     end
+
+    assert_equal [], Language.find_by_interpreter(nil)
   end
 
   def test_find

test/test_samples.rb

@@ -82,9 +82,4 @@ class TestSamples < Test::Unit::TestCase
       end
     end
   end
-
-  def test_shebang
-    assert_equal "crystal", Linguist.interpreter_from_shebang("#!/usr/bin/env bin/crystal")
-    assert_equal "python2", Linguist.interpreter_from_shebang("#!/usr/bin/python2.4")
-  end
 end

test/test_shebang.rb

@@ -0,0 +1,38 @@
+require_relative "./helper"
+
+class TestShebang < Test::Unit::TestCase
+  include Linguist
+
+  def assert_interpreter(interpreter, body)
+    assert_equal interpreter, Shebang.interpreter(body)
+  end
+
+  def test_shebangs
+    assert_interpreter nil, ""
+    assert_interpreter nil, "foo"
+    assert_interpreter nil, "#bar"
+    assert_interpreter nil, "#baz"
+    assert_interpreter nil, "///"
+    assert_interpreter nil, "\n\n\n\n\n"
+    assert_interpreter nil, " #!/usr/sbin/ruby"
+    assert_interpreter nil, "\n#!/usr/sbin/ruby"
+
+    assert_interpreter "ruby", "#!/usr/sbin/ruby\n# bar"
+    assert_interpreter "ruby", "#!/usr/bin/ruby\n# foo"
+    assert_interpreter "ruby", "#!/usr/sbin/ruby"
+    assert_interpreter "ruby", "#!/usr/sbin/ruby foo bar baz\n"
+
+    assert_interpreter "Rscript", "#!/usr/bin/env Rscript\n# example R script\n#\n"
+    assert_interpreter "crystal", "#!/usr/bin/env bin/crystal"
+    assert_interpreter "ruby", "#!/usr/bin/env ruby\n# baz"
+
+    assert_interpreter "bash", "#!/usr/bin/bash\n"
+    assert_interpreter "sh", "#!/bin/sh"
+    assert_interpreter "python", "#!/bin/python\n# foo\n# bar\n# baz"
+    assert_interpreter "python2", "#!/usr/bin/python2.7\n\n\n\n"
+    assert_interpreter "python3", "#!/usr/bin/python3\n\n\n\n"
+    assert_interpreter "sbcl", "#!/usr/bin/sbcl --script\n\n"
+    assert_interpreter "perl", "#! perl"
+  end
+
+end