licensee 5.0.0 → 6.0.0b1

data/test/functions.rb

@@ -19,8 +19,6 @@ def license_from_path(path)
   license
 end
 
-FakeBlob = Licensee::FilesystemRepository::Blob
-
 def chaos_monkey(string)
   Random.rand(3).times do
     string[Random.rand(string.length)] = SecureRandom.base64(Random.rand(3))
@@ -35,28 +33,19 @@ def verify_license_file(license, chaos = false, wrap=false)
   text = chaos_monkey(text) if chaos
   text = wrap(text, wrap) if wrap
 
-  blob = FakeBlob.new(text)
-  license_file = Licensee::ProjectFile.new(blob, "LICENSE")
+  license_file = Licensee::Project::LicenseFile.new(text)
 
-  actual = license_file.match
+  actual = license_file.license
   msg = "No match for #{expected}."
 
-  unless actual
-    Licensee.matchers.each do |matcher|
-      matcher = matcher.new(license_file)
-      msg << "#{matcher.class}: #{matcher.confidence}% #{matcher.match.inspect}\n"
-    end
-    msg << "Here's the test text:\n#{text}"
-  end
-
   assert actual, msg
   assert_equal expected, actual.key, "expeceted #{expected} but got #{actual.key} for .match. Confidence: #{license_file.confidence}. Method: #{license_file.matcher.class}"
 end
 
 def wrap(text, line_width=80)
   text = text.clone
-  copyright = /^#{Licensee::CopyrightMatcher::REGEX}$/i.match(text)
-  text.gsub! /^#{Licensee::CopyrightMatcher::REGEX}$/i, '[COPYRIGHT]' if copyright
+  copyright = /^#{Licensee::Matchers::Copyright::REGEX}$/i.match(text)
+  text.gsub! /^#{Licensee::Matchers::Copyright::REGEX}$/i, '[COPYRIGHT]' if copyright
   text.gsub! /([^\n])\n([^\n])/, '\1 \2'
   text = text.split("\n").collect do |line|
     line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip : line

data/test/test_licensee.rb

@@ -4,7 +4,7 @@ class TestLicensee < Minitest::Test
   should "know the licenses" do
     assert_equal Array, Licensee.licenses.class
     assert_equal 15, Licensee.licenses.size
-    assert_equal 23, Licensee.licenses(:hidden => true).size
+    assert_equal 24, Licensee.licenses(:hidden => true).size
     assert_equal Licensee::License, Licensee.licenses.first.class
   end
 
@@ -23,16 +23,4 @@ class TestLicensee < Minitest::Test
       Licensee.confidence_threshold = 90
     end
   end
-
-  context "npm-bower matcher" do
-    should "be disabled by default" do
-      refute Licensee.matchers.include? Licensee::NpmBowerMatcher
-    end
-
-    should "be enable-able" do
-      Licensee.package_manager_files = true
-      assert Licensee.matchers.include? Licensee::NpmBowerMatcher
-      Licensee.package_manager_files = false
-    end
-  end
 end

data/test/test_licensee_copyright_matcher.rb

@@ -1,61 +1,52 @@
 # encoding=utf-8
 require 'helper'
 
-class TestLicenseeCopyrightMatcher < Minitest::Test
-
-  def setup
-    text = "Copyright 2015 Ben Balter"
-    blob = FakeBlob.new(text)
-    @file = Licensee::ProjectFile.new(blob, "LICENSE")
-  end
-
+class TestLicenseeCopyrightMatchers < Minitest::Test
   should "match the license" do
-    assert_equal "no-license", Licensee::CopyrightMatcher.match(@file).key
+    text = "Copyright 2015 Ben Balter"
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
   end
 
   should "know the match confidence" do
-    assert_equal 100, Licensee::CopyrightMatcher.new(@file).confidence
+    text = "Copyright 2015 Ben Balter"
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal 100, Licensee::Matchers::Copyright.new(file).confidence
   end
 
   should "match Copyright (C) copyright notices" do
     text = "Copyright (C) 2015 Ben Balter"
-    blob = FakeBlob.new(text)
-    file = Licensee::ProjectFile.new(blob, "LICENSE")
-    assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
   end
 
   should "match Copyright © copyright notices" do
     text = "copyright © 2015 Ben Balter"
-    blob = FakeBlob.new(text)
-    file = Licensee::ProjectFile.new(blob, "LICENSE")
-    assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
   end
 
   should "not false positive" do
     text = File.open(Licensee::License.find("mit").path).read.split("---").last
-    blob = FakeBlob.new(text)
-    file = Licensee::ProjectFile.new(blob, "LICENSE")
-    assert_equal nil, Licensee::CopyrightMatcher.match(file)
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal nil, Licensee::Matchers::Copyright.new(file).match
   end
 
   should "handle UTF-8 encoded copyright notices" do
     text = "Copyright (c) 2010-2014 Simon Hürlimann"
-    blob = FakeBlob.new(text)
-    file = Licensee::ProjectFile.new(blob, "LICENSE")
-    assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
   end
 
   should "handle ASCII-8BIT encoded copyright notices" do
     text = "Copyright \xC2\xA92015 Ben Balter`".force_encoding("ASCII-8BIT")
-    blob = FakeBlob.new(text)
-    file = Licensee::ProjectFile.new(blob, "LICENSE")
-    assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
   end
 
   should "match comma, separated dates" do
     text = "Copyright (c) 2003, 2004 Ben Balter"
-    blob = FakeBlob.new(text)
-    file = Licensee::ProjectFile.new(blob, "LICENSE")
-    assert_equal "no-license", Licensee::CopyrightMatcher.match(file).key
+    file = Licensee::Project::LicenseFile.new(text)
+    assert_equal "no-license", Licensee::Matchers::Copyright.new(file).match.key
   end
  end

data/test/test_licensee_dice_matcher.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+class TestLicenseeDiceMatchers < Minitest::Test
+  def setup
+    text = license_from_path(Licensee::License.find("mit").path)
+    @mit = Licensee::Project::LicenseFile.new(text)
+  end
+
+  should "match the license" do
+    assert_equal "mit", Licensee::Matchers::Dice.new(@mit).match.key
+  end
+
+  should "know the match confidence" do
+    matcher = Licensee::Matchers::Dice.new(@mit)
+    assert matcher.confidence > 95, "#{matcher.confidence} < 95"
+  end
+
+  should "calculate max delta" do
+    assert_equal 83.7, Licensee::Matchers::Dice.new(@mit).max_delta
+  end
+end

data/test/test_licensee_exact_matcher.rb

@@ -1,18 +1,16 @@
 require 'helper'
 
-class TestLicenseeExactMatcher < Minitest::Test
-
+class TestLicenseeExactMatchers < Minitest::Test
   def setup
     text = File.open(Licensee::License.find("mit").path).read.split("---").last
-    blob = FakeBlob.new(text)
-    @mit = Licensee::ProjectFile.new(blob, "LICENSE")
+    @mit = Licensee::Project::LicenseFile.new(text)
   end
 
   should "match the license" do
-    assert_equal "mit", Licensee::ExactMatcher.match(@mit).key
+    assert_equal "mit", Licensee::Matchers::Exact.new(@mit).match.key
   end
 
   should "know the match confidence" do
-    assert_equal 100, Licensee::ExactMatcher.new(@mit).confidence
+    assert_equal 100, Licensee::Matchers::Exact.new(@mit).confidence
   end
 end

data/test/test_licensee_gemspec_matcher.rb

@@ -1,18 +1,10 @@
 require 'helper'
 
-class TestLicenseeGemspecMatcher < Minitest::Test
-  def setup
-    Licensee.package_manager_files = true
-  end
-
-  def teardown
-    Licensee.package_manager_files = false
-  end
-
+class TestLicenseeGemspecMatchers < Minitest::Test
   should "detect its own license" do
     root = File.expand_path "../", File.dirname(__FILE__)
-    project = Licensee::Project.new(root)
-    matcher = Licensee::GemspecMatcher.new(project.package_file)
+    project = Licensee::GitProject.new(root, detect_packages: true)
+    matcher = Licensee::Matchers::Gemspec.new(project.package_file)
     assert_equal "mit", matcher.send(:license_property)
     assert_equal "mit", matcher.match.key
   end

data/test/test_licensee_license.rb

@@ -112,16 +112,6 @@ class TestLicenseeLicense < Minitest::Test
       assert_equal expected,  Licensee::License.find("gpl-3.0").name_without_version
     end
 
-    should "know if the license contains the name without version" do
-      refute Licensee::License.find("cc0-1.0").body_includes_name?
-      assert Licensee::License.find("agpl-3.0").body_includes_name?
-    end
-
-    should "know if the license contains the nickname" do
-      refute Licensee::License.find("mit").body_includes_nickname?
-      assert Licensee::License.find("apache-2.0").body_includes_nickname?
-    end
-
     Licensee.licenses.each do |license|
       should "strip the version number from the #{license.name} license" do
         assert license.name_without_version
@@ -132,13 +122,13 @@ class TestLicenseeLicense < Minitest::Test
   describe "class methods" do
     should "know license names" do
       assert_equal Array, Licensee::License.keys.class
-      assert_equal 23, Licensee::License.keys.size
+      assert_equal 24, Licensee::License.keys.size
     end
 
     should "load the licenses" do
       assert_equal Array, Licensee::License.all.class
       assert_equal 15, Licensee::License.all.size
-      assert_equal 23, Licensee::License.all(:hidden => true).size
+      assert_equal 24, Licensee::License.all(:hidden => true).size
       assert_equal Licensee::License, Licensee::License.all.first.class
     end
 

data/test/test_licensee_npm_bower_matcher.rb

@@ -1,32 +1,26 @@
 require 'helper'
 
-class TestLicenseeNpmBowerMatcher < Minitest::Test
-
-  def setup
-    Licensee.package_manager_files = true
-  end
-
-  def teardown
-    Licensee.package_manager_files = false
-  end
-
+class TestLicenseeNpmBowerMatchers < Minitest::Test
   should "detect NPM files" do
-    project = Licensee::Project.new fixture_path "npm"
-    matcher = Licensee::NpmBowerMatcher.new(project.package_file)
+    pkg = File.read fixture_path("npm/package.json")
+    pkgfile = Licensee::Project::PackageInfo.new(pkg)
+    matcher = Licensee::Matchers::NpmBower.new(pkgfile)
     assert_equal "mit", matcher.send(:license_property)
     assert_equal "mit", matcher.match.key
   end
 
   should "detect Bower files" do
-    project = Licensee::Project.new fixture_path "bower"
-    matcher = Licensee::NpmBowerMatcher.new(project.package_file)
+    pkg = File.read fixture_path("bower/bower.json")
+    pkgfile = Licensee::Project::PackageInfo.new(pkg)
+    matcher = Licensee::Matchers::NpmBower.new(pkgfile)
     assert_equal "mit", matcher.send(:license_property)
     assert_equal "mit", matcher.match.key
   end
 
   should "not err on non-spdx licenses" do
-    project = Licensee::Project.new fixture_path "npm-non-spdx"
-    matcher = Licensee::NpmBowerMatcher.new(project.package_file)
+    pkg = File.read fixture_path("npm-non-spdx/package.json")
+    pkgfile = Licensee::Project::PackageInfo.new(pkg)
+    matcher = Licensee::Matchers::NpmBower.new(pkgfile)
     assert_equal "mit-1.0", matcher.send(:license_property)
     assert_equal nil, matcher.match
   end

data/test/test_licensee_project.rb

@@ -3,66 +3,65 @@ require 'fileutils'
 
 class TestLicenseeProject < Minitest::Test
 
-  [true, false].each do |as_git|
-    describe(as_git ? "git" : "non-git") do
-
-      def make_project(fixture_name, as_git)
-        fixture = fixture_path fixture_name
-
-        unless as_git
+  ["git", "filesystem"].each do |project_type|
+    describe("#{project_type} repository project") do
+      if project_type == "git"
+        def make_project(fixture_name)
+          fixture = fixture_path fixture_name
+          Licensee::GitProject.new(fixture)
+        end
+      else
+        def make_project(fixture_name)
           dest = File.join("tmp", "fixtures", fixture_name)
           FileUtils.mkdir_p File.dirname(dest)
-          system "git", "clone", "-q", fixture, dest
+          system "git", "clone", "-q", fixture_path(fixture_name), dest
           FileUtils.rm_r File.join(dest, ".git")
-          fixture = dest
-        end
 
-        Licensee::Project.new fixture
-      end
+          Licensee::FSProject.new(dest)
+        end
 
-      unless as_git
         def teardown
-          FileUtils.rm_rf "tmp/fixtures"
+          FileUtils.rm_rf "tmp/fixtures" 
         end
       end
 
       should "detect the license file" do
-        project = make_project "licenses.git", as_git
-        assert_instance_of Licensee::ProjectFile, project.license_file
+        project = make_project "licenses.git"
+        assert_instance_of Licensee::Project::LicenseFile, project.license_file
       end
 
       should "detect the license" do
-        project = make_project "licenses.git", as_git
+        project = make_project "licenses.git"
         assert_equal "mit", project.license.key
       end
 
       should "detect an atypically cased license file" do
-        project = make_project "case-sensitive.git", as_git
-        assert_instance_of Licensee::ProjectFile, project.license_file
+        project = make_project "case-sensitive.git"
+        assert_instance_of Licensee::Project::LicenseFile, project.license_file
       end
 
       should "detect MIT-LICENSE licensed projects" do
-        project = make_project "named-license-file-prefix.git", as_git
+        project = make_project "named-license-file-prefix.git"
         assert_equal "mit", project.license.key
       end
 
       should "detect LICENSE-MIT licensed projects" do
-        project = make_project "named-license-file-suffix.git", as_git
+        project = make_project "named-license-file-suffix.git"
         assert_equal "mit", project.license.key
       end
 
       should "not error out on repos with folders names license" do
-        project = make_project "license-folder.git", as_git
+        project = make_project "license-folder.git"
         assert_equal nil, project.license
       end
 
       should "detect licence files" do
-        project = make_project "licence.git", as_git
+        project = make_project "licence.git"
         assert_equal "mit", project.license.key
       end
 
       should "detect an unlicensed project" do
-        project = make_project "no-license.git", as_git
+        project = make_project "no-license.git"
         assert_equal nil, project.license
       end
     end
@@ -78,19 +77,9 @@ class TestLicenseeProject < Minitest::Test
     end
   end
 
-
   describe "packages" do
-
-    def setup
-      Licensee.package_manager_files = true
-    end
-
-    def teardown
-      Licensee.package_manager_files = false
-    end
-
     should "detect a package file" do
-      project = Licensee::Project.new fixture_path "npm"
+      project = Licensee::GitProject.new(fixture_path("npm.git"), detect_packages: true)
       assert_equal "package.json", project.package_file.filename
       assert_equal "mit", project.license.key
     end

data/test/test_licensee_project_file.rb

@@ -4,22 +4,18 @@ class TestLicenseeProjectFile < Minitest::Test
 
   def setup
     @repo = Rugged::Repository.new(fixture_path("licenses.git"))
-    blob = 'bcb552d06d9cf1cd4c048a6d3bf716849c2216cc'
-    @file = Licensee::ProjectFile.new(@repo.lookup(blob), "LICENSE")
+    blob, _ = Rugged::Blob.to_buffer(@repo, 'bcb552d06d9cf1cd4c048a6d3bf716849c2216cc')
+    @file = Licensee::Project::LicenseFile.new(blob)
     @gpl = Licensee::License.find "GPL-3.0"
     @mit = Licensee::License.find "MIT"
   end
 
   should "read the file" do
-    assert @file.contents =~ /MIT/
+    assert @file.content =~ /MIT/
   end
 
   should "match the license" do
-    assert_equal "mit", @file.match.key
-  end
-
-  should "know the path" do
-    assert_equal "LICENSE", @file.path
+    assert_equal "mit", @file.license.key
   end
 
   should "calculate confidence" do
@@ -31,7 +27,6 @@ class TestLicenseeProjectFile < Minitest::Test
   end
 
   context "license filename scoring" do
-
     EXPECTATIONS = {
       "license"            => 1.0,
       "LICENCE"            => 1.0,
@@ -52,7 +47,7 @@ class TestLicenseeProjectFile < Minitest::Test
 
     EXPECTATIONS.each do |filename, expected|
       should "score a license named `#{filename}` as `#{expected}`" do
-        assert_equal expected, Licensee::ProjectFile.license_score(filename)
+        assert_equal expected, Licensee::Project::LicenseFile.name_score(filename)
       end
     end
   end